collavre 0.22.0 → 0.23.0

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

@@ -10,6 +10,11 @@ module Creatives
     # than its entire match set.
     PERMISSION_FILTER_BATCH = 200
 
+    # Page size for the top-nav "Chats" feed (the comment filter). The list is
+    # unbounded by nature (it grows with every commented creative), so it is
+    # paginated instead of materialized whole.
+    COMMENT_CHATS_PER_PAGE = 30
+
     Result = Struct.new(
       :creatives,
       :parent_creative,
@@ -18,6 +23,7 @@ module Creatives
       :overall_progress,
       :allowed_creative_ids,
       :progress_map,
+      :pagination,
       keyword_init: true
     )
 
@@ -38,7 +44,8 @@ module Creatives
         shared_list: shared_list,
         overall_progress: result[:overall_progress] || 0,
         allowed_creative_ids: result[:allowed_ids],
-        progress_map: result[:progress_map]
+        progress_map: result[:progress_map],
+        pagination: result[:pagination]
       )
     end
 
@@ -83,29 +90,46 @@ module Creatives
 
       result = pipeline.call
 
-      return empty_result if result.matched_ids.empty?
+      # The comment ("Chats") path still returns a pagination object on an empty
+      # match so the client gets consistent metadata; other filters short-circuit.
+      return empty_result if result.matched_ids.empty? && params[:comment] != "true"
 
       # For search/comment filters, return matched items directly (flat results sorted by relevance)
       # Unless search_mode=tree is specified, which returns tree structure instead
       # For other filters (tags, progress), return tree start nodes
       if (params[:search].present? || params[:comment] == "true") && params[:search_mode] != "tree"
-        matched_creatives = Creative.where(id: result.matched_ids.to_a)
-          .order(:sequence)
-          .select { |c| readable?(c) }
+        parent = params[:id] ? Creative.find_by(id: params[:id]) : nil
 
-        # Sort by comment updated_at for comment filter
         if params[:comment] == "true"
-          matched_creatives = matched_creatives.sort_by { |c| c.comments.maximum(:updated_at) || c.updated_at }.reverse
+          # Top-nav "Chats" list: one page of commented creatives, newest chat
+          # first. The matched set is permission-filtered in a single batch and
+          # the recency ordering is computed by the DB (LIMIT/OFFSET over a
+          # grouped MAX(comments.updated_at)), so response cost is a fixed page
+          # regardless of how many chats exist. This replaces an unbounded load
+          # that ran a per-row readable? query and a per-row MAX(updated_at)
+          # aggregate (two N+1s that grew with the chat count).
+          page = comment_chats_page(result.matched_ids)
+          {
+            creatives: page[:creatives],
+            parent: parent,
+            allowed_ids: result.allowed_ids,
+            overall_progress: result.overall_progress,
+            progress_map: result.progress_map,
+            pagination: page[:pagination]
+          }
+        else
+          matched_creatives = Creative.where(id: result.matched_ids.to_a)
+            .order(:sequence)
+            .select { |c| readable?(c) }
+
+          {
+            creatives: matched_creatives,
+            parent: parent,
+            allowed_ids: result.allowed_ids,
+            overall_progress: result.overall_progress,
+            progress_map: result.progress_map
+          }
         end
-
-        parent = params[:id] ? Creative.find_by(id: params[:id]) : nil
-        {
-          creatives: matched_creatives,
-          parent: parent,
-          allowed_ids: result.allowed_ids,
-          overall_progress: result.overall_progress,
-          progress_map: result.progress_map
-        }
       else
         start_nodes = determine_start_nodes(result.allowed_ids)
         parent = params[:id] ? Creative.find_by(id: params[:id]) : nil
@@ -119,6 +143,51 @@ module Creatives
       end
     end
 
+    # One page of the "Chats" feed from the comment-matched id set, ordered by
+    # most-recent comment. Permission filtering is batched (PermissionFilter does
+    # a handful of IN queries, not one per row) and the recency sort + windowing
+    # happen in SQL, so neither cost scales with the total number of chats.
+    def comment_chats_page(matched_ids)
+      per_page = comment_chats_per_page
+      page = comment_chats_page_number
+      offset = (page - 1) * per_page
+
+      readable_ids = PermissionFilter.new(user: user).readable_ids(matched_ids.to_a)
+      return { creatives: [], pagination: pagination_meta(page, false) } if readable_ids.empty?
+
+      # Fetch one extra row to detect whether a further page exists. id is the
+      # tiebreaker so the order is total and stable across page boundaries.
+      page_ids = Creative.where(id: readable_ids)
+        .joins(:comments)
+        .group("creatives.id")
+        .order(Arel.sql("MAX(comments.updated_at) DESC, creatives.id DESC"))
+        .offset(offset)
+        .limit(per_page + 1)
+        .pluck("creatives.id")
+
+      has_more = page_ids.size > per_page
+      page_ids = page_ids.first(per_page)
+
+      by_id = Creative.where(id: page_ids).index_by(&:id)
+      creatives = page_ids.filter_map { |id| by_id[id] }
+
+      { creatives: creatives, pagination: pagination_meta(page, has_more) }
+    end
+
+    def comment_chats_per_page
+      per = params[:per_page].presence&.to_i || COMMENT_CHATS_PER_PAGE
+      per <= 0 || per > 100 ? COMMENT_CHATS_PER_PAGE : per
+    end
+
+    def comment_chats_page_number
+      page = params[:page].presence&.to_i || 1
+      page < 1 ? 1 : page
+    end
+
+    def pagination_meta(page, has_more)
+      { page: page, next_page: has_more ? page + 1 : nil, has_more: has_more }
+    end
+
     def simple_search?
       params[:search].present? && params[:simple].present? &&
         params[:search_mode] != "tree" && params[:comment] != "true"

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

@@ -195,7 +195,8 @@ module Creatives
         progress: creative.progress,
         origin_id: creative.origin_id,
         content_type: effective.data&.dig("content_type"),
-        markdown_source: origin_writable ? effective.data&.dig("markdown_source") : nil
+        markdown_source: origin_writable ? effective.data&.dig("markdown_source") : nil,
+        markdown_editor: effective.data&.dig("editor")
       }
     end
 

data/app/services/collavre/gemini_parent_recommender.rb

@@ -55,7 +55,7 @@ module Collavre
     def default_client
       AiClient.new(
         vendor: "google",
-        model: "gemini-3-flash-preview",
+        model: "gemini-3.1-flash-lite",
         system_prompt: nil
       )
     end

data/app/services/collavre/inbox_reply_service.rb

@@ -64,6 +64,11 @@ module Collavre
         content: @comment.content,
         user: @comment.user,
         quoted_comment: original,
+        # quoted_comment is set only for linkage to the message being answered.
+        # Mark it as a "question" so review_message? stays false — otherwise the
+        # agent's response would update the quoted comment in place (the review
+        # flow) instead of posting a new reply. See Comment#review_message?.
+        review_type: :question,
         private: false
       )
 

data/app/services/collavre/markdown_converter.rb

@@ -48,12 +48,22 @@ module Collavre
           source
         end
 
-        # Render with commonmarker (GFM extensions: table, strikethrough, autolink, tasklist, tagfilter)
+        # Render with commonmarker (GFM extensions: table, strikethrough, autolink, tasklist, tagfilter).
+        # hardbreaks: a single newline becomes <br>, mirroring the JS renderer (marked breaks:true)
+        # and the canonical markdown_source, which stores consecutive rich-editor lines one-per-line
+        # rather than separated by a blank line.
+        #
+        # syntax_highlighter: nil disables comrak's built-in syntect highlighter, which otherwise
+        # bakes a fixed base16-ocean.dark theme into the stored HTML as inline `style=` attributes
+        # (e.g. `<pre style="background-color:#2b303b"><span style="color:#bf616a">`). Those inline
+        # styles override our theme-aware code_highlight.css palette and are blind to light/dark mode.
+        # Disabling it emits a plain `<pre lang="ruby"><code>…</code></pre>`; the client re-tokenizes
+        # with highlight.js so the rendered creative matches the editor (and respects the theme).
         html = Commonmarker.to_html(input, options: {
           parse: { smart: true },
-          render: { unsafe: true },
+          render: { unsafe: true, hardbreaks: true },
           extension: { table: true, strikethrough: true, autolink: true, tasklist: true, tagfilter: true }
-        })
+        }, plugins: { syntax_highlighter: nil })
 
         html.strip!
         html

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 if comment.action.blank?
+
+        JSON.parse(comment.action)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

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!
 
@@ -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