collavre 0.24.0 → 0.25.0

data/app/models/collavre/comment.rb

@@ -8,6 +8,84 @@ module Collavre
     # matches the same prefix to remove them once the waiter is dequeued.
     WAITING_NOTICE_PREFIX = "⏳"
 
+    # What a waiting notice speaks for, written by the door that posted it.
+    # "topic" is the deduplicated notice coalescing allows a topic exactly one
+    # of; "task" is the per-deferral notice the opt-out posts, which names its
+    # waiter in waiting_notice_task_id. nil is a notice from before this was
+    # recorded — see #cancel_queued_tasks_for_waiting_notice.
+    WAITING_NOTICE_TOPIC = "topic"
+    WAITING_NOTICE_TASK = "task"
+
+    # Take down the per-deferral notice that speaks for this waiter, if it had
+    # one.
+    #
+    # A "task" notice is on screen for exactly as long as its waiter is queued:
+    # it names that waiter in waiting_notice_task_id and
+    # #cancel_queued_tasks_for_waiting_notice stops that waiter and nothing
+    # else. So the moment the waiter leaves the queue the notice is a stop
+    # button for work that cannot be stopped — and no sweep will collect it,
+    # since the drained sweep only runs when the topic queue empties and the
+    # waiter itself will never be promoted again.
+    #
+    # It therefore comes down wherever the waiter leaves, which is why this
+    # lives here beside the columns rather than in one of those callers: the
+    # promotion (AgentOrchestrator.cleanup_waiter_notice!) and the fold
+    # (Orchestration::TaskCoalescer) are two doors onto the same rule, and a
+    # third would otherwise write its own copy or forget.
+    #
+    # The destroy is marked as a system removal: the waiter is being promoted or
+    # folded, not abandoned by the user, so the cancellation callback must not
+    # fire on top of it.
+    def self.remove_waiter_notices!(creative_id:, topic_id:, task_ids:)
+      task_ids = Array(task_ids).compact
+      return if task_ids.empty?
+
+      where(creative_id: creative_id, topic_id: topic_id, user_id: nil,
+            waiting_notice_scope: WAITING_NOTICE_TASK,
+            waiting_notice_task_id: task_ids).find_each do |notice|
+        notice.suppress_waiter_cancellation = true
+        notice.destroy
+      end
+    end
+
+    # Take down every "⏳" defer notice in the topic that no longer speaks for a
+    # queued waiter.
+    #
+    # Asked per notice, not per topic. "Is anything queued here?" is a topic-wide
+    # question and no notice asks it: a "task" notice speaks for the one waiter
+    # it names, and a shared one for every queued waiter *except* those a
+    # surviving "task" notice claims — see #represented_queued_waiters, which
+    # this and the stop button both go through so the two cannot drift. A topic
+    # can therefore hold waiters while a notice standing in it represents none
+    # of them, and that notice is a "⏳" line whose stop button selects nothing.
+    #
+    # Nothing else collects it. A cancelled waiter is never promoted, so the
+    # promotion's cleanup never runs for it, and a promotion that leaves only
+    # claimed waiters behind is exactly the case a topic-wide drain check reads
+    # as "still busy".
+    #
+    # Scoped to topic_concurrency_defer notices. A :delayed notice shares the
+    # prefix but explains a rate-limited or busy dispatch that is still going to
+    # run, so it speaks for no waiter by design and is not this sweep's to take.
+    #
+    # Asked under the same lock the notice doors take, so "nobody is queued" is
+    # a deferral's own before-or-after rather than a guess: it either commits
+    # its waiter before this reads, and keeps its notice, or after, and posts
+    # one of its own.
+    def self.remove_stranded_waiting_notices!(creative_id:, topic_id:)
+      transaction do
+        Collavre::Orchestration::TopicSlot.lock!(topic_id, creative_id)
+
+        where(creative_id: creative_id, topic_id: topic_id, user_id: nil,
+              topic_concurrency_defer: true).find_each do |notice|
+          next if notice.represented_queued_waiters.any?
+
+          notice.suppress_waiter_cancellation = true
+          notice.destroy
+        end
+      end
+    end
+
     # Use non-namespaced partial path for backward compatibility
     def to_partial_path
       "comments/comment"
@@ -83,7 +161,6 @@ module Collavre
     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
     has_one :snapshot_as_result, class_name: "Collavre::CommentSnapshot", foreign_key: :result_comment_id, dependent: :nullify
     belongs_to :selected_version, class_name: "Collavre::CommentVersion", optional: true
@@ -97,6 +174,8 @@ module Collavre
 
     attribute :skip_default_user, :boolean, default: false
     attribute :skip_dispatch, :boolean, default: false
+    attribute :skip_link_preview, :boolean, default: false
+    attribute :skip_notification_revision, :boolean, default: false
     # Set by AgentOrchestrator.cleanup_waiting_notices! so destroying a notice as
     # part of *promoting* a waiter does not run the user-delete cancel cascade
     # (which would cancel other still-queued waiters in the same topic).
@@ -104,8 +183,8 @@ module Collavre
 
     before_validation :use_origin_creative
     before_validation :assign_default_user, on: :create
-    before_validation :assign_main_topic, on: :create
-    before_save :apply_link_previews, if: :should_apply_link_previews?
+    include TopicMembership
+    after_commit :enqueue_link_preview, on: [ :create, :update ], if: :link_preview_enqueue_required?
     after_create_commit :dispatch_to_orchestration
     after_create_commit :resume_trigger_loop_if_awaiting
 
@@ -123,6 +202,24 @@ module Collavre
       quoted_comment_id.present? && !review_type_question?
     end
 
+    # Which of `ids` are review requests, in one query. The orchestration paths
+    # that decide whether a trigger may be folded away or moved forward hold
+    # comment *ids*, not records, and run over a whole burst at once.
+    #
+    # `review_type: [nil, review]` rather than `where.not(question)`: the column
+    # is NULL for an ordinary review (only /compress-style questions set it), and
+    # SQL's `review_type != 1` drops NULL rows — which is every real review.
+    def self.review_message_ids(ids)
+      ids = Array(ids).compact.map(&:to_i).uniq
+      return [] if ids.empty?
+
+      review_messages.where(id: ids).pluck(:id)
+    end
+
+    scope :review_messages, -> {
+      where.not(quoted_comment_id: nil).where(review_type: [ nil, review_types[:review] ])
+    }
+
     # public for db migration
     def creative_snippet
       creative.creative_snippet
@@ -160,6 +257,8 @@ module Collavre
     end
 
     def cancel_pending_tasks
+      stranded_scopes = []
+
       # Cancel tasks triggered by this comment (no creative_id scoping —
       # CommentMoveService can change comment.creative_id without updating
       # existing tasks, so scoping would miss moved-comment tasks).
@@ -169,9 +268,35 @@ module Collavre
       Task.where(status: %w[pending running queued delegated]).find_each do |task|
         next unless task.trigger_event_payload&.dig("comment", "id") == id
 
+        # An un-started task can be the survivor of a coalesced burst, answering
+        # several comments at once. Cancelling it because its anchor was deleted
+        # would throw away the absorbed comments too — they have no task of their
+        # own left (TaskCoalescer cancelled those) and no other delivery path
+        # (session-backed agents receive only the trigger). Re-anchor onto the
+        # newest surviving merged comment instead; only a task with nothing left
+        # to say is cancelled.
+        next if reanchor_coalesced_task(task)
+
         was_delegated = task.status == "delegated"
         task.update!(status: "cancelled")
 
+        # A waiter cancelled here leaves the queue without ever being promoted,
+        # exactly as a folded one does — so the notice that spoke for it is left
+        # naming a task no longer queued, and its stop button cancels nothing.
+        # This door needs no policy change at all: the opt-out posts the notice,
+        # deleting the prompt cancels the waiter, and a sibling still parked
+        # keeps the drained sweep from ever running.
+        Comment.remove_waiter_notices!(
+          creative_id: task.creative_id, topic_id: task.topic_id, task_ids: task.id
+        )
+
+        # …and with coalescing on there is no per-deferral notice to take down:
+        # the waiter's signal is the topic's *shared* one, which the call above
+        # deliberately leaves alone. If this cancellation was the last thing that
+        # notice spoke for, nothing else will ever collect it. Swept after the
+        # loop, once every task this deletion cancels has left the queue.
+        stranded_scopes << [ task.creative_id, task.topic_id ]
+
         # Delegated tasks live past their job: the AiAgentJob already returned,
         # holding the agent slot under task.id and counting against the per-topic
         # serializer. Mirror the cancel path used elsewhere to free both.
@@ -179,17 +304,6 @@ module Collavre
         if task.agent
           Collavre::Orchestration::ResourceTracker.for(task.agent).release!(task.id)
         end
-        if task.parent_task_id.present?
-          begin
-            Collavre::Comments::WorkflowExecutor.new(task.parent_task).fail_subtask!(
-              task, error_message: "Triggering comment was deleted"
-            )
-          rescue StandardError => e
-            Rails.logger.error(
-              "[Comment#cancel_pending_tasks] fail_subtask! failed for task #{task.id}: #{e.message}"
-            )
-          end
-        end
         Collavre::Orchestration::AgentOrchestrator.dequeue_next_for_topic(task.topic_id, task.creative_id)
       end
 
@@ -202,16 +316,215 @@ module Collavre
       # waiter is being advanced, not abandoned, and cancelling other still-queued
       # waiters would drop their work (multi-slot orphan recovery must not cancel
       # the rest).
+      stranded_scopes.uniq.each do |cancelled_creative_id, cancelled_topic_id|
+        next unless cancelled_creative_id
+
+        Comment.remove_stranded_waiting_notices!(
+          creative_id: cancelled_creative_id, topic_id: cancelled_topic_id
+        )
+      end
+
       if waiting_notice? && topic_concurrency_defer? && !suppress_waiter_cancellation
         cancel_queued_tasks_for_waiting_notice
       end
     end
 
+    # Move a coalesced task off this (deleted) comment and onto the newest of
+    # the comments it had absorbed. Returns true when the task was rescued, so
+    # the caller skips cancellation.
+    #
+    # Only un-started tasks: a `running`/`delegated` task has already been handed
+    # its payload, so re-anchoring changes nothing and deleting the prompt must
+    # still stop the turn.
+    def reanchor_coalesced_task(task)
+      return false unless %w[queued pending].include?(task.status)
+
+      Task.transaction { reanchor_locked_task(task) }
+    rescue ActiveRecord::RecordNotFound
+      # The task went away between the scan and the lock (a cascading delete).
+      # Nothing to rescue, and nothing left to cancel either.
+      false
+    end
+
+    # The lock body. `task` is the object cancel_pending_tasks' scan loaded, and
+    # everything derived here has to come from the row as it stands *now*:
+    # TaskCoalescer folds a sibling into this same task under a lock this path
+    # never took, so a fold committing between that scan and the write below
+    # would be overwritten by the pre-fold payload — and the absorbed sibling is
+    # already cancelled, so its comment has no task left to answer it.
+    #
+    # lock! reloads in place rather than into a second object: the caller keeps
+    # using this instance (it cancels the task when we return false), so swapping
+    # identity here would hand it stale attributes.
+    #
+    # Status is re-read for the same reason. A snapshot that said `queued` may
+    # have been promoted and started since, and a started turn has already been
+    # handed its payload — deleting the prompt must stop it, not re-target it.
+    def reanchor_locked_task(task)
+      task.lock!
+      return false unless %w[queued pending].include?(task.status)
+
+      payload = task.trigger_event_payload || {}
+      merged = Array(payload[Collavre::Orchestration::TaskCoalescer::PAYLOAD_KEY])
+                 .compact.map(&:to_i).uniq - [ id ]
+      return false if merged.empty?
+
+      # Anything else in the merge window may have been deleted too. Newest by id:
+      # created_at is stamped per writing process, so a burst can carry skewed or
+      # tied timestamps (same reason MergedTriggerComments orders by id).
+      #
+      # Scoped to this turn's creative/topic: a merged comment moved elsewhere
+      # while the task waited (CommentMoveService#perform_move reassigns
+      # creative_id) is no longer part of it, and adopting it as the anchor would
+      # point the reply at a creative the agent may have no share on.
+      #
+      # The turn is the TASK's scope, not this comment's. cancel_pending_tasks
+      # looks tasks up with no creative scoping precisely because a move rewrites
+      # the comment without touching the task it triggered — so an anchor moved
+      # away and then deleted would be searching the creative it was moved *to*,
+      # find nothing there, and cancel a turn whose absorbed comments are all
+      # still sitting in the creative the task belongs to.
+      #
+      # Asked through MergedTriggerComments.in_turn, the same predicate that
+      # decides what the turn delivers. Eligibility is not only about *where* a
+      # comment is: a comment made private (or turned into an approval surface)
+      # after it was absorbed is one dispatch_to_orchestration would refuse to
+      # trigger on, and in_turn already drops it from the merged blocks. The
+      # anchor is delivered as the trigger itself, with no filter in front of
+      # it, so a lookup of its own here is how withdrawn content reaches the
+      # agent through the one door that never filters.
+      in_scope = Collavre::AiAgent::MergedTriggerComments
+                   .in_turn(merged, "creative" => { "id" => task.creative_id },
+                                    "topic" => { "id" => task.topic_id })
+                   .order(:id).to_a
+      replacement = in_scope.last
+      return false unless replacement
+
+      # Through the same door the refresh uses, so the promotion is recorded as
+      # an acquired anchor either way: this task was created to answer the
+      # comment being deleted, not this one.
+      payload = Collavre::Orchestration::TaskCoalescer.reanchor_payload(payload, replacement)
+      payload = payload.merge(
+        # Rebuilt from the in-scope ids rather than merged through
+        # absorb_into_payload, which would fold the out-of-scope ones straight
+        # back in from the payload it starts from. The new anchor is excluded so
+        # the promoted comment is not delivered twice.
+        Collavre::Orchestration::TaskCoalescer::PAYLOAD_KEY =>
+          (in_scope.map(&:id) - [ replacement.id ]).sort
+      )
+      task.update!(trigger_event_payload: payload)
+
+      Rails.logger.info(
+        "[Comment#cancel_pending_tasks] Re-anchored coalesced task #{task.id} from deleted " \
+        "comment #{id} to comment #{replacement.id}"
+      )
+      true
+    end
+
+    # Cancel *every* queued waiter this notice speaks for, not just the newest.
+    #
+    # Cancelling one was right while each deferral posted its own notice: the
+    # newest queued task was the one that notice belonged to. A topic now gets
+    # exactly one deduplicated notice
+    # (Orchestration::AgentOrchestrator.with_deduped_topic_notice), and with
+    # topic_max_concurrent_jobs > 1 it can stand for waiters from several agents
+    # — coalescing folds same-agent siblings only. Deleting it while cancelling
+    # one of them leaves the rest queued with nothing on screen representing
+    # them and no stop control, and nothing reposts a notice until the next
+    # deferral happens by.
+    #
+    # …but only a notice that actually *was* deduplicated. With
+    # coalesce_pending_tasks off, post_waiting_notice deliberately skips the
+    # dedup path and posts one notice per deferral: there the 1:1 still holds and
+    # cancelling every queued task would let a user discard unrelated waiters by
+    # dismissing one notice, defeating the opt-out.
+    #
+    # Which kind this is comes off the row (waiting_notice_scope), written by
+    # whichever door posted it. It used to be inferred from whether a sibling
+    # notice still stood, on the reasoning that the dedup path allows a topic
+    # exactly one — but the two kinds coexist as soon as the policy differs
+    # between agents or changes while a topic still has waiters, and then the
+    # inference inverts: the shared notice reads as a per-deferral one and takes
+    # down the newest queued waiter, which is very likely the one the *other*
+    # notice speaks for. A row cannot be classified by its neighbours when the
+    # neighbours are a different kind.
+    #
+    # Queued only. A task holding the topic slot (pending/running/…) is not
+    # waiting on anything; the notice surfaces it separately as
+    # topic_blocking_task, with its own stop button.
     def cancel_queued_tasks_for_waiting_notice
+      represented_queued_waiters.each { |task| task.update!(status: "cancelled") }
+
+      # Cancelling is the other way a topic queue empties, and it has no
+      # promotion behind it to run the drained check. The notices that spoke for
+      # the waiters just cancelled went with them — this one is being destroyed,
+      # and a per-deferral sibling names a task that is now cancelled — but a
+      # *shared* notice is only ever taken down by that check, so without this
+      # it is left on screen describing a wait that is over.
+      Comment.remove_stranded_waiting_notices!(creative_id: creative_id, topic_id: topic_id)
+    end
+
+    # The queued waiters this notice speaks for — what its stop button cancels,
+    # and equally what keeps it on screen. Public because
+    # .remove_stranded_waiting_notices! asks the same question from the other
+    # side: a notice representing nobody is a stop control for work that can no
+    # longer be stopped. Two answers to one question is how the button and the
+    # sweep would come to disagree about what a notice is for.
+    public def represented_queued_waiters
+      case waiting_notice_scope
+      when WAITING_NOTICE_TASK
+        # Speaks for exactly the waiter it was posted with — and for nothing at
+        # all once that waiter has been folded away or promoted.
+        queued_topic_waiters.select { |task| task.id == waiting_notice_task_id }
+      when WAITING_NOTICE_TOPIC
+        # Every queued waiter in the topic except those a per-deferral notice
+        # speaks for: the shared notice was never their signal, and their own
+        # stop control is — or is about to be — on screen.
+        #
+        # Asked of the waiter, not of the notices standing beside it. A waiter and
+        # its notice commit in two steps, so an opted-out waiter is queued before
+        # any notice names it; classifying it by what survives in that window
+        # cancels a turn that was only deferred, and leaves no notice behind to
+        # say so. What speaks for a waiter is settled when it is parked.
+        claimed = sibling_notice_waiter_ids
+        queued_topic_waiters.reject { |task| task_claims_own_notice?(task, claimed) }
+      else
+        # Posted before this was recorded. Nothing on the row says which kind it
+        # was, so keep the behaviour those notices were created under rather than
+        # guess: widening it would discard work, narrowing it would disarm the
+        # only stop control an in-flight wait has.
+        queued_topic_waiters.first(1)
+      end
+    end
+
+    def queued_topic_waiters
       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")
+      scope.order(created_at: :desc).to_a
+    end
+
+    # Does this waiter have a per-deferral notice of its own, rather than being
+    # one the topic's shared notice speaks for?
+    #
+    # The waiter says so itself, recorded when it was parked. Rows parked before
+    # that was recorded say nothing, so they keep the answer they were parked
+    # under — the surviving sibling notices — rather than being guessed at in
+    # either direction: widening this discards work, narrowing it disarms the only
+    # stop control an in-flight wait has.
+    def task_claims_own_notice?(task, claimed)
+      case task.waiting_notice_scope
+      when WAITING_NOTICE_TASK then true
+      when WAITING_NOTICE_TOPIC then false
+      else claimed.include?(task.id)
+      end
+    end
+
+    # Waiter ids a still-standing per-deferral notice represents. Runs
+    # after_destroy_commit, so this notice is already out of the query.
+    def sibling_notice_waiter_ids
+      Comment.where(creative_id: creative_id, topic_id: topic_id, user_id: nil,
+                    waiting_notice_scope: WAITING_NOTICE_TASK)
+             .pluck(:waiting_notice_task_id).compact
     end
 
     def dispatch_to_orchestration
@@ -252,7 +565,7 @@ module Collavre
       # when the local Claude TUI answered the prompt, leaving pending_tool_call
       # set on the server for the rest of a locally-approved tool run.
 
-      SystemEvents::Dispatcher.dispatch("comment_created", dispatch_payload)
+      SystemEvents::Dispatcher.dispatch("comment_created", dispatch_payload, source: "comment_callback")
     rescue StandardError => e
       Rails.logger.error(
         "[Comment#dispatch_to_orchestration] Failed for comment #{id}: " \
@@ -332,14 +645,6 @@ module Collavre
       )
     end
 
-    def assign_main_topic
-      return if topic_id.present?
-      return unless creative
-
-      fallback = user || Collavre.current_user || creative.user
-      self.topic = creative.main_topic(fallback_user: fallback)
-    end
-
     def use_origin_creative
       return unless creative
       self.creative = creative.effective_origin
@@ -352,14 +657,14 @@ module Collavre
       errors.add(:creative, "must be an origin creative")
     end
 
-    def should_apply_link_previews?
-      will_save_change_to_content? && content.present?
+    def enqueue_link_preview
+      return if content.blank?
+
+      CommentLinkPreviewJob.perform_later(id, content, notification_revision)
     end
 
-    def apply_link_previews
-      self.content = CommentLinkFormatter.new(content).format
-    rescue StandardError => e
-      Rails.logger.warn("Comment link preview formatting failed: #{e.class} #{e.message}")
+    def link_preview_enqueue_required?
+      saved_change_to_content? && !skip_link_preview
     end
 
     def images_must_be_images

data/app/models/collavre/comment_notification_delivery.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Collavre
+  class CommentNotificationDelivery < ApplicationRecord
+    self.table_name = "comment_notification_deliveries"
+
+    CLAIM_TIMEOUT = 5.minutes
+
+    validates :delivery_key, :recipient_id, :message, presence: true
+
+    scope :ready_for_push, -> {
+      where(push_enqueued_at: nil)
+        .where("push_claimed_at IS NULL OR push_claimed_at < ?", CLAIM_TIMEOUT.ago)
+    }
+
+    def enqueue_push!
+      claim_token = SecureRandom.uuid
+      claimed_at = Time.current
+      claimed = self.class.ready_for_push
+                          .where(id: id)
+                          .update_all(
+                            push_claim_token: claim_token,
+                            push_claimed_at: claimed_at,
+                            updated_at: claimed_at
+                          )
+      return false unless claimed == 1
+
+      job = PushNotificationJob.perform_later(recipient_id, message: message, link: link)
+      enqueue_succeeded = job && (!job.respond_to?(:successfully_enqueued?) || job.successfully_enqueued?)
+      unless enqueue_succeeded
+        enqueue_error = job.respond_to?(:enqueue_error) ? job.enqueue_error : nil
+        raise enqueue_error || ActiveJob::EnqueueError.new("Push notification enqueue failed")
+      end
+
+      acknowledged = self.class
+        .where(id: id, push_claim_token: claim_token, push_enqueued_at: nil)
+        .update_all(
+          push_enqueued_at: Time.current,
+          push_claim_token: nil,
+          push_claimed_at: nil,
+          updated_at: Time.current
+        )
+      raise ActiveRecord::StaleObjectError.new(self, "enqueue push") unless acknowledged == 1
+
+      true
+    rescue StandardError
+      release_claim(claim_token)
+      raise
+    end
+
+    private
+
+    def release_claim(claim_token)
+      self.class.where(id: id, push_claim_token: claim_token).update_all(
+        push_claim_token: nil,
+        push_claimed_at: nil,
+        updated_at: Time.current
+      )
+    end
+  end
+end

data/app/models/collavre/comment_presence_store/cache_batches.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Collavre
+  class CommentPresenceStore
+    module CacheBatches
+      def active_subscriptions_for_creatives(ids, user_id, subscription_keys, subscriptions)
+        lease_keys = subscription_lease_keys(ids, user_id, subscription_keys, subscriptions)
+        leases = Rails.cache.read_multi(*lease_keys.values)
+        ids.to_h do |creative_id|
+          subscription_ids = Array(subscriptions[subscription_keys.fetch(creative_id)])
+          active_ids = subscription_ids.select { |id| leases[lease_keys.fetch([ creative_id, id ])] }
+          [ creative_id, active_ids ]
+        end
+      end
+
+      def subscription_lease_keys(ids, user_id, subscription_keys, subscriptions)
+        ids.flat_map do |creative_id|
+          Array(subscriptions[subscription_keys.fetch(creative_id)]).map do |subscription_id|
+            [ [ creative_id, subscription_id ], subscription_lease_key(creative_id, user_id, subscription_id) ]
+          end
+        end.to_h
+      end
+
+      def viewing_topics_from_subscriptions(subscriptions_by_creative_id, user_id)
+        topic_keys = subscriptions_by_creative_id.to_h do |creative_id, subscription_ids|
+          [ creative_id, subscription_ids.map { |id| topic_key(creative_id, user_id, id) } ]
+        end
+        cached_topics = Rails.cache.read_multi(*topic_keys.values.flatten)
+        topic_keys.transform_values { |keys| keys.flat_map { |key| Array(cached_topics[key]) }.compact.uniq }
+      end
+
+      def cached_user_ids(ids)
+        cached = Rails.cache.read_multi(*ids.map { |creative_id| key(creative_id) })
+        ids.to_h { |creative_id| [ creative_id, cached[key(creative_id)] || [] ] }
+      end
+
+      def cached_subscriptions_for(user_ids_by_creative_id)
+        keys = subscription_keys_by_pair(user_ids_by_creative_id)
+        Rails.cache.read_multi(*keys.values)
+      end
+
+      def cached_subscription_leases(user_ids_by_creative_id, subscriptions)
+        keys = subscription_keys_by_pair(user_ids_by_creative_id)
+        lease_keys = keys.flat_map do |(creative_id, user_id), subscription_key|
+          Array(subscriptions[subscription_key]).map { |id| subscription_lease_key(creative_id, user_id, id) }
+        end
+        Rails.cache.read_multi(*lease_keys)
+      end
+
+      def present_users_from_cache(user_ids_by_creative_id, subscriptions, leases)
+        user_ids_by_creative_id.to_h do |creative_id, user_ids|
+          users = user_ids.select { |user_id| active_subscription_ids_from_cache(creative_id, user_id, subscriptions, leases).any? }
+          [ creative_id, users ]
+        end
+      end
+
+      def subscription_keys_by_pair(user_ids_by_creative_id)
+        user_ids_by_creative_id.flat_map do |creative_id, user_ids|
+          user_ids.map { |user_id| [ [ creative_id, user_id ], subscriptions_key(creative_id, user_id) ] }
+        end.to_h
+      end
+    end
+  end
+end