collavre 0.24.0 → 0.25.0

data/app/controllers/collavre/desktop_setup_controller.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Collavre
+  # First-run flow for the desktop CLI Proxy. Credential generation and the
+  # local proxy process live in Tauri; this controller only persists the
+  # resulting gateway after verifying a short-lived, local-only handoff token.
+  class DesktopSetupController < ApplicationController
+    allow_unauthenticated_access only: %i[show create_account]
+
+    STEPS = %w[account install adapters ready].freeze
+    DESKTOP_GATEWAY_NAME = "Collavre Desktop CLI Proxy"
+    PRESETS = {
+      "claude" => [ "Claude Code", "collavre-desktop-claude-code@ai.local", "paperclip/claude_local" ],
+      "codex" => [ "Codex", "collavre-desktop-codex@ai.local", "paperclip/codex_local" ]
+    }.freeze
+
+    def show
+      @step = params[:step].to_s
+      @step = STEPS.first unless STEPS.include?(@step)
+      @user = Current.user
+      @account_required = !Collavre::User.where(system_admin: true).exists?
+      return if @account_required
+
+      # Recovery is entered without a step after native setup fails. An
+      # authenticated owner must resume at installation rather than see the
+      # sign-in-only account panel.
+      if @user&.system_admin?
+        @step = "install" if @step == "account"
+        return
+      end
+
+      # A desktop in open mode can have an ordinary user signed in when native
+      # proxy recovery opens this page. That user cannot mint a registration
+      # token, so keep them on the account step where they can sign out and use
+      # the owner's account instead of presenting a broken install action.
+      if @user
+        session[:return_to_after_authenticating] = collavre.desktop_setup_path(step: @step)
+        @step = "account"
+        return
+      end
+
+      # A failed native registration leaves the proxy installed but incomplete.
+      # Preserve the exact setup destination through login so the local owner
+      # can retry without deleting Keychain entries or app data.
+      @step = "install" if @step == "account"
+      session[:return_to_after_authenticating] = collavre.desktop_setup_path(step: @step)
+      redirect_to collavre.new_session_path
+    end
+
+    def create_account
+      return unless require_desktop_mode!
+      return unless require_loopback!
+
+      @user = Collavre::User.new(account_params)
+      Collavre::User.transaction do
+        unless @user.save
+          @step = "account"
+          @account_required = true
+          render :show, status: :unprocessable_entity
+          return
+        end
+
+        # The absence check is part of the UPDATE itself. Two overlapping local
+        # signups can both save, but only one can become the first administrator.
+        admin_exists = Collavre::User.where(system_admin: true).arel.exists
+        promoted = Collavre::User.where(id: @user.id)
+          .where(admin_exists.not)
+          .update_all(email_verified_at: Time.current, system_admin: true)
+        raise FirstAdministratorAlreadyCreated unless promoted == 1
+      end
+      start_new_session_for(@user)
+      redirect_to collavre.desktop_setup_path(step: :install)
+    rescue FirstAdministratorAlreadyCreated
+      redirect_to collavre.new_session_path, alert: t("collavre.desktop_setup.account.already_created")
+    end
+
+    def registration_token
+      return unless require_desktop_mode!
+      return unless require_loopback!
+      unless Current.user&.system_admin?
+        head :forbidden
+        return
+      end
+
+      render json: { token: registration_verifier.generate({ user_id: Current.user.id, expires_at: 5.minutes.from_now.to_i }) }
+    end
+
+    private
+
+    FirstAdministratorAlreadyCreated = Class.new(StandardError)
+
+    def account_params
+      params.require(:admin).permit(:name, :email, :password, :password_confirmation)
+    end
+
+    def registration_verifier
+      Rails.application.message_verifier("desktop-gateway-registration")
+    end
+
+    def require_loopback!
+      addr = IPAddr.new(request.remote_addr.to_s)
+      addr = addr.native if addr.respond_to?(:ipv4_mapped?) && addr.ipv4_mapped?
+      return true if addr.loopback?
+
+      head :forbidden
+      false
+    rescue IPAddr::InvalidAddressError
+      head :forbidden
+      false
+    end
+
+    def require_desktop_mode!
+      return true if Rails.application.config.x.desktop_proxy_setup == true
+
+      head :not_found
+      false
+    end
+  end
+end

data/app/controllers/collavre/desktop_sidecar_health_controller.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Collavre
+  # Authenticates the Rails child to the native shell before its webview is
+  # navigated to the local server. The secret is generated per launch by Tauri
+  # and exists only in this child process environment.
+  class DesktopSidecarHealthController < ActionController::API
+    def show
+      return unless require_loopback!
+
+      secret = ENV.fetch("COLLAVRE_DESKTOP_SIDECAR_SECRET", "")
+      return head :not_found if secret.blank?
+
+      challenge = params.require(:challenge)
+      digest = OpenSSL::HMAC.digest("SHA256", secret, challenge)
+      render plain: Base64.urlsafe_encode64(digest, padding: false), content_type: "text/plain"
+    rescue ActionController::ParameterMissing
+      head :bad_request
+    end
+
+    private
+
+    def require_loopback!
+      addr = IPAddr.new(request.remote_addr.to_s)
+      addr = addr.native if addr.respond_to?(:ipv4_mapped?) && addr.ipv4_mapped?
+      return true if addr.loopback?
+
+      head :forbidden
+      false
+    rescue IPAddr::InvalidAddressError
+      head :forbidden
+      false
+    end
+  end
+end

data/app/controllers/collavre/features_controller.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Collavre
+  # Public, server-rendered guide pages for the empty-chat feature cards.
+  #
+  # These double as landing content, so they are readable signed out and share
+  # the landing layout/stylesheet. All copy lives in config/locales/features.*.yml
+  # under collavre.features.pages.<key>; the registry only supplies which keys
+  # exist and in what order.
+  class FeaturesController < ApplicationController
+    allow_unauthenticated_access
+    layout "collavre/landing"
+
+    def index
+      @cards = Collavre::FeatureCardRegistry.with_builtin_guide
+    end
+
+    def show
+      @card = Collavre::FeatureCardRegistry.find(params[:key])
+      # An unknown key, or a card documented by a vendor engine elsewhere, has no
+      # page here — both are a 404 rather than a blank shell of headings.
+      raise ActiveRecord::RecordNotFound unless @card&.builtin_guide?
+
+      @page = self.class.page_content(@card.key)
+    end
+
+    # Reads a page's copy out of i18n, normalizing the parts a translator can
+    # legitimately omit. Missing translations come back from I18n as a String
+    # rather than the Array/Hash shape the view walks, so coerce before render
+    # instead of letting the view guard every access.
+    def self.page_content(key)
+      scope = "collavre.features.pages.#{key}"
+
+      {
+        title: I18n.t("#{scope}.title", default: ""),
+        tagline: I18n.t("#{scope}.tagline", default: ""),
+        meta_description: I18n.t("#{scope}.meta_description", default: ""),
+        sections: array_of_hashes(I18n.t("#{scope}.sections", default: [])),
+        tips: array_of_strings(I18n.t("#{scope}.tips", default: []))
+      }
+    end
+
+    def self.array_of_hashes(value)
+      return [] unless value.is_a?(Array)
+
+      value.select { |entry| entry.is_a?(Hash) && entry[:body].present? }
+    end
+
+    def self.array_of_strings(value)
+      return [] unless value.is_a?(Array)
+
+      value.select { |entry| entry.is_a?(String) && entry.present? }
+    end
+
+    private_class_method :array_of_hashes, :array_of_strings
+  end
+end

data/app/controllers/collavre/invites_controller.rb

@@ -1,5 +1,10 @@
 module Collavre
   class InvitesController < ApplicationController
+    LINK_PREVIEW_USER_AGENT_PATTERN = /
+      bot\b|crawler\b|spider\b|preview\b|scrap(?:e|er)?\b|
+      facebookexternalhit|whatsapp|iframely|embedly
+    /ix
+
     allow_unauthenticated_access only: :show
     before_action :set_invitation, only: :show
 
@@ -17,11 +22,17 @@ module Collavre
     end
 
     def show
-      @invitation.update(clicked_at: Time.current) unless @invitation.clicked_at
+      return if @invitation.clicked_at || link_preview_crawler?
+
+      @invitation.update(clicked_at: Time.current)
     end
 
     private
 
+    def link_preview_crawler?
+      request.user_agent.to_s.match?(LINK_PREVIEW_USER_AGENT_PATTERN)
+    end
+
     def set_invitation
       @invitation = Invitation.find_by_token_for(:invite, params[:token])
     rescue ActiveSupport::MessageVerifier::InvalidSignature

data/app/controllers/collavre/llm_models_controller.rb

@@ -0,0 +1,8 @@
+module Collavre
+  class LlmModelsController < ApplicationController
+    def destroy
+      LlmModel.find_by(id: params[:id])&.destroy!
+      head :no_content
+    end
+  end
+end

data/app/controllers/collavre/notices_controller.rb

@@ -0,0 +1,20 @@
+module Collavre
+  class NoticesController < ApplicationController
+    def dismiss
+      key = params[:key].to_s
+
+      Current.user.with_lock do
+        dismissed = Current.user.dismissed_notices || []
+        Current.user.update!(dismissed_notices: (dismissed + [ key ]).uniq)
+      end
+
+      render json: { success: true, dismissed_notices: Current.user.dismissed_notices }
+    end
+
+    def restore_all
+      Current.user.update!(dismissed_notices: [])
+
+      render json: { success: true, dismissed_notices: Current.user.dismissed_notices }
+    end
+  end
+end

data/app/controllers/collavre/tasks_controller.rb

@@ -2,6 +2,21 @@
 
 module Collavre
   class TasksController < ApplicationController
+    def active_statuses
+      task_ids = params[:task_ids].to_s.split(",").map(&:to_i).reject(&:zero?)
+      return render json: { tasks: [] } if task_ids.empty?
+
+      tasks = Task.where(id: task_ids).includes(:creative)
+      results = tasks.filter_map do |task|
+        creative = task.creative || Creative.find_by(id: task.trigger_event_payload&.dig("creative", "id"))
+        next unless creative&.has_permission?(Current.user, :read)
+
+        { id: task.id, active: task.active? }
+      end
+
+      render json: { tasks: results }
+    end
+
     def cancel
       task = Task.find(params[:id])
       creative = task.creative || Creative.find_by(id: task.trigger_event_payload&.dig("creative", "id"))
@@ -10,10 +25,6 @@ module Collavre
         return head :forbidden
       end
 
-      unless %w[running pending queued pending_approval delegated].include?(task.status)
-        return head :unprocessable_entity
-      end
-
       # These statuses count against the topic slot (occupying_topic_slot) yet no
       # live worker will run AiAgentJob's ensure-block drain for them:
       #   - delegated / pending_approval already returned from the job holding the
@@ -25,8 +36,31 @@ module Collavre
       # cancelling the blocker leaves agent capacity and the next waiter stuck
       # until stuck recovery. release!/dequeue are idempotent (dequeue is bounded
       # by topic_at_capacity?), so a racing live worker that also drains is harmless.
-      held_slot_without_worker = %w[pending delegated pending_approval].include?(task.status)
-      task.update!(status: "cancelled")
+      previous_status = task.cancel_if_active!
+      return head :unprocessable_entity unless previous_status
+
+      held_slot_without_worker = Task::HELD_SLOT_WITHOUT_WORKER.include?(previous_status)
+
+      # The third door a waiter leaves the queue through without ever being
+      # promoted — "queued" is in the whitelist above, so the user's own stop
+      # button is one of them. Its "task" notice names this task, and a notice
+      # naming a task that is no longer queued cancels nothing when dismissed:
+      # a stop button for work that can no longer be stopped. Nothing else
+      # collects it either — the task is never promoted, so
+      # cleanup_waiter_notice! never runs for it, and the drained sweep needs
+      # the topic queue to empty, which any sibling waiter prevents.
+      Comment.remove_waiter_notices!(
+        creative_id: task.creative_id, topic_id: task.topic_id, task_ids: task.id
+      )
+
+      # With coalescing on this waiter had no notice of its own — the topic's
+      # shared one spoke for it, and the call above deliberately does not touch
+      # that kind. Same stranding, one row over.
+      if task.creative_id
+        Comment.remove_stranded_waiting_notices!(
+          creative_id: task.creative_id, topic_id: task.topic_id
+        )
+      end
 
       if held_slot_without_worker && task.agent
         Collavre::Orchestration::ResourceTracker.for(task.agent).release!(task.id)

data/app/controllers/collavre/topics_controller.rb

@@ -1,5 +1,8 @@
 module Collavre
   class TopicsController < ApplicationController
+    rescue_from Topics::TopicMove::SourceChangedError, with: :render_source_changed
+    rescue_from Topics::TopicMove::MoveBlockedError, with: :render_active_tasks
+
     include Collavre::CreativePermissionGuard
 
     before_action :set_creative
@@ -10,7 +13,11 @@ module Collavre
     def index
       is_owner = @creative.user == Current.user
       can_manage = @creative.has_permission?(Current.user, :admin) || is_owner
-      can_create_topic = can_manage || @creative.has_permission?(Current.user, :write)
+      # Mirrors require_creative_write! — the gate on #create and
+      # #set_primary_agent. Reported as two capabilities because the client gates
+      # two separate controls on it, and only #update/#destroy/#move/#reorder
+      # need :admin.
+      can_write = can_manage || @creative.has_permission?(Current.user, :write)
 
       # Eagerly ensure Main (and System for inboxes) exist BEFORE loading
       # active_topics. Otherwise the first inbox visit sees no System topic in
@@ -21,23 +28,20 @@ module Collavre
       system_topic = @creative.inbox? ? @creative.system_topic(fallback_user: Current.user) : nil
 
       active_topics = @creative.topics.active.includes(primary_agent: { avatar_attachment: :blob }).order(:created_at).to_a
-      archived_topics = @creative.topics.archived.order(:created_at)
-
-      last_topic_id = if Current.user
-                        UserCreativePreference
-                          .where(user_id: Current.user.id, creative_id: @creative.id)
-                          .pick(:last_topic_id)
-      end
+      archived_topics = @creative.topics.archived.includes(primary_agent: { avatar_attachment: :blob }).order(:created_at).to_a
+      unread_counts_by_topic = Creatives::CommentBadgeIndex.new(user: Current.user)
+        .unread_counts_by_topic(@creative)
 
       system_topic_id = system_topic&.id
       main_topic_id = main_topic.id
 
       render json: {
-        topics: active_topics.map { |t| topic_json(t) },
-        archived_topics: archived_topics,
+        topics: active_topics.map { |t| topic_json(t, unread_count: unread_counts_by_topic.fetch(t.id, 0)) },
+        archived_topics: archived_topics.map { |t| topic_json(t, unread_count: unread_counts_by_topic.fetch(t.id, 0)) },
         can_manage: can_manage,
-        can_create_topic: can_create_topic,
-        last_topic_id: last_topic_id,
+        can_create_topic: can_write,
+        can_set_primary_agent: can_write,
+        **Topics::LastTopicPreferencePayload.new(creative: @creative, user: Current.user).call,
         is_inbox: @creative.inbox?,
         system_topic_id: system_topic_id,
         main_topic_id: main_topic_id,
@@ -46,15 +50,27 @@ module Collavre
     end
 
     def create
+      requested_agent = params[:agent_id].present? ? User.find_by(id: params[:agent_id]) : nil
+
+      # No topic yet, so a Claude Channel agent is rejected on an inbox creative:
+      # a topic created here never carries a session_id, which is the only place
+      # Matcher#eligible_in_inbox? will route one.
+      rejection = requested_agent&.ai_user? &&
+        Topic.primary_agent_rejection(@creative, requested_agent)
+      if rejection
+        render json: { errors: [ unassignable_agent_message(requested_agent, rejection) ] },
+               status: :unprocessable_entity and return
+      end
+
       topic = @creative.topics.build(topic_params)
       topic.user = Current.user
 
       Topic.transaction do
         if topic.save
           agent = nil
-          if params[:agent_id].present?
-            agent = User.find_by(id: params[:agent_id])
-            topic.set_primary_agent!(agent) if agent&.ai_user?
+          if requested_agent&.ai_user?
+            agent = requested_agent
+            topic.set_primary_agent!(agent)
           end
 
           # Move comments to the new topic if comment_ids provided
@@ -89,7 +105,7 @@ module Collavre
     def update
       topic = @creative.topics.find(params[:id])
 
-      if topic.update(topic_params)
+      if mutate_locked_topic(topic) { |current_topic| current_topic.update(topic_params) }
         broadcast_topic_event("updated", topic: topic_json(topic))
         render json: topic_json(topic)
       else
@@ -104,9 +120,9 @@ module Collavre
         render json: { error: I18n.t("collavre.topics.cannot_delete_main") }, status: :unprocessable_entity and return
       end
 
-      topic_id = topic.id
-      topic_name = topic.name
-      topic.destroy
+      topic_id, topic_name = Topics::TopicDestroy.new(
+        topic: topic, source_creative: @creative
+      ).call
 
       # Best-effort orphaned-cron notice. Must never break the core deletion:
       # if it raises, swallow + log so broadcast/head still run.
@@ -140,31 +156,37 @@ module Collavre
         render json: { error: I18n.t("collavre.topics.move.duplicate_name", name: topic.name) }, status: :unprocessable_entity and return
       end
 
-      Topic.transaction do
-        topic.comments.update_all(creative_id: target_creative.id)
-        topic.update!(creative: target_creative)
+      # A Claude Channel session topic is looked up as
+      # inbox.topics.find_by(primary_agent_id:, session_id:) — re-parenting it
+      # takes it out of that scope, so the next registration would fork a second
+      # topic and Matcher#eligible_in_inbox? would stop routing the session
+      # agent. Same identity that #set_primary_agent refuses to rewrite.
+      if topic.session_id.present?
+        render json: { error: I18n.t("collavre.topics.move.session_topic_locked") }, status: :unprocessable_entity and return
       end
 
-      # update_all above skips counter-cache callbacks, so recompute
-      # comments_count on both sides after re-parenting the comments.
-      Creative.reset_counters(source_creative.id, :comments)
-      Creative.reset_counters(target_creative.id, :comments)
-
-      broadcast_topic_event("deleted", topic_id: topic.id)
-      broadcast_topic_event("created", creative: target_creative, topic: topic.slice(:id, :name))
+      effects = Topics::TopicMoveEffects.new(topic, source_creative, target_creative)
+      released_agent, released_reason = Topics::TopicMove.new(
+        topic: topic, target_creative: target_creative
+      ).call(after_commit: effects.method(:call))
 
       render json: {
         success: true,
         topic: topic.slice(:id, :name),
         target_creative_id: target_creative.id,
         target_creative_name: target_creative.creative_snippet,
-        missing_members: missing_members_for_move(source_creative, target_creative)
+        missing_members: missing_members_for_move(source_creative, target_creative),
+        released_primary_agent: released_agent && {
+          id: released_agent.id,
+          name: released_agent.display_name,
+          message: released_primary_agent_message(released_agent, released_reason, target_creative)
+        }
       }
     end
 
     def archive
       topic = @creative.topics.find(params[:id])
-      topic.archive!
+      mutate_locked_topic(topic, &:archive!)
 
       broadcast_topic_event("archived", topic: topic.slice(:id, :name))
       render json: { success: true }
@@ -172,7 +194,7 @@ module Collavre
 
     def unarchive
       topic = @creative.topics.find(params[:id])
-      topic.unarchive!
+      mutate_locked_topic(topic, &:unarchive!)
 
       broadcast_topic_event("unarchived", topic: topic.slice(:id, :name, :archived_at))
       render json: { success: true }
@@ -197,13 +219,44 @@ module Collavre
 
     def set_primary_agent
       topic = @creative.topics.find(params[:id])
+
+      # On a Claude Channel session topic, primary_agent_id is not a routing pin
+      # but part of the session identity: Matcher#eligible_in_inbox? needs it to
+      # route the session agent at all, and SessionProvisioner#find_or_create_topic
+      # reuses the topic by (primary_agent_id, session_id). Clearing or reassigning
+      # it would leave a live session unroutable and split the next registration
+      # into a second topic. Releasing a session is session teardown, not an
+      # avatar click.
+      if topic.session_id.present?
+        render json: { error: I18n.t("collavre.topics.session_topic_locked") },
+               status: :unprocessable_entity and return
+      end
+
+      # A blank agent_id clears the assignment. The primary agent is an exclusive
+      # assignment (it silences every other agent's ambient routing), so the user
+      # needs a way back to an unassigned topic — otherwise a single avatar click
+      # would permanently dedicate the topic to one agent.
+      if params[:agent_id].blank?
+        mutate_locked_topic(topic) { |current_topic| current_topic.set_primary_agent!(nil) }
+
+        broadcast_topic_event("updated", topic: topic_json_with_agent(topic, nil))
+
+        return render json: { success: true, topic: topic_json_with_agent(topic, nil) }
+      end
+
       agent = User.find_by(id: params[:agent_id])
 
       unless agent&.ai_user?
         render json: { error: I18n.t("collavre.topics.not_ai_agent") }, status: :unprocessable_entity and return
       end
 
-      topic.set_primary_agent!(agent)
+      rejection = Topic.primary_agent_rejection(@creative, agent, topic: topic)
+      if rejection
+        render json: { error: unassignable_agent_message(agent, rejection) },
+               status: :unprocessable_entity and return
+      end
+
+      mutate_locked_topic(topic) { |current_topic| current_topic.set_primary_agent!(agent) }
 
       broadcast_topic_event("updated", topic: topic_json_with_agent(topic, agent))
 
@@ -212,10 +265,43 @@ module Collavre
 
     private
 
+    def render_source_changed(error)
+      render json: { error: error.message }, status: :forbidden
+    end
+
+    def render_active_tasks(error)
+      render json: { error: error.message }, status: :unprocessable_entity
+    end
+
     def set_creative
       @creative = Creative.find(params[:creative_id]).effective_origin
     end
 
+    def mutate_locked_topic(topic, &) = Topics::TopicMutation.new(topic: topic, source_creative: @creative).call(&)
+
+    # A move can now release the pin for either reason, and the advice differs:
+    # sharing the target creative fixes a missing-permission release, but a
+    # Claude Channel session agent stays confined to its own session topic no
+    # matter what is shared — telling the user to share and re-assign would send
+    # them after a fix that cannot work.
+    def released_primary_agent_message(agent, rejection, target_creative)
+      key = if rejection == :session_agent_outside_session_topic
+              "collavre.topics.move.primary_agent_released_session_agent"
+      else
+              "collavre.topics.move.primary_agent_released"
+      end
+
+      I18n.t(key, agent: agent.display_name, creative: target_creative.creative_snippet)
+    end
+
+    def unassignable_agent_message(agent, rejection)
+      if rejection == :session_agent_outside_session_topic
+        I18n.t("collavre.topics.session_agent_not_assignable", name: agent.display_name)
+      else
+        I18n.t("collavre.topics.agent_no_creative_access", name: agent.display_name)
+      end
+    end
+
     # When a topic moves to a different creative, members who had access on the
     # source creative may lose visibility on the target. Returns the human
     # members who are effectively present on the source (owner + feedback-or-
@@ -257,36 +343,27 @@ module Collavre
       end
     end
 
+
     def topic_params
       params.require(:topic).permit(:name)
     end
 
     def generate_next_topic_name
-      prefix = I18n.t("collavre.topics.default_name_prefix")
-      existing_numbers = @creative.topics.active
-        .where("name LIKE ?", "#{Topic.sanitize_sql_like(prefix)}%")
-        .pluck(:name)
-        .filter_map { |n|
-          suffix = n.delete_prefix(prefix)
-          suffix.match?(/\A\d+\z/) ? suffix.to_i : nil
-        }
-
-      next_number = (existing_numbers.max || 0) + 1
-      "#{prefix}#{next_number}"
+      Topics::NextName.for(@creative)
     end
 
-    def topic_json(topic)
-      data = topic.slice(:id, :name, :source_topic_id)
-      if topic.primary_agent
-        data[:primary_agent] = agent_json(topic.primary_agent)
-      end
-      data
+    # Delegated to Topics::Serializer so the topic MCP tools, which broadcast the
+    # same events from outside a request, cannot describe a topic differently
+    # from this controller.
+    def topic_json(topic, unread_count: nil)
+      Topics::Serializer.call(topic, unread_count: unread_count)
     end
 
+    # Always carries a :primary_agent key, explicitly nil when cleared. The client
+    # merges this payload into its cached topic, so an omitted key would leave a
+    # stale avatar on screen instead of removing it.
     def topic_json_with_agent(topic, agent)
-      data = topic.slice(:id, :name, :source_topic_id)
-      data[:primary_agent] = agent_json(agent)
-      data
+      Topics::Serializer.with_agent(topic, agent)
     end
 
     def agent_json(agent)