collavre 0.20.2 → 0.21.0

data/app/controllers/collavre/channels_controller.rb

@@ -0,0 +1,23 @@
+module Collavre
+  class ChannelsController < ApplicationController
+    include Collavre::CreativePermissionGuard
+
+    before_action :set_channel
+    before_action :require_creative_write!
+
+    def destroy
+      @channel.dismiss!
+      head :no_content
+    end
+
+    private
+
+    def set_channel
+      # Look up among not-yet-dismissed channels (active OR detached). The X
+      # button must work on detached chips too — those linger so the user can
+      # still see the final merge/close badge until they choose to clear it.
+      @channel = Channel.not_dismissed.find(params[:id])
+      @creative = @channel.topic.creative.effective_origin
+    end
+  end
+end

data/app/controllers/collavre/creatives_controller.rb

@@ -118,6 +118,7 @@ module Collavre
 
           trigger_loop_data = @creative.data&.dig("trigger", "loop")
           parent_trigger_enabled = @creative.parent&.drop_trigger_enabled? || false
+          can_edit = @creative.has_permission?(Current.user, :write)
 
           etag = [
             "creative",
@@ -132,7 +133,9 @@ module Collavre
             "trigger_v3",
             trigger_loop_data&.dig("state"),
             trigger_loop_data&.dig("current_iteration"),
-            parent_trigger_enabled
+            parent_trigger_enabled,
+            "can_edit",
+            can_edit
           ].join(":")
 
           if stale?(etag: etag, last_modified: last_modified, public: false)
@@ -142,6 +145,13 @@ module Collavre
             else
                       @creative.ancestors.count + 1
             end
+            sanitized_data = @creative.effective_origin(Set.new).data
+            # markdown_source is exposed via the top-level `markdown_source:` field for writers;
+            # exclude it from the editable `data` payload so the metadata YAML editor can't
+            # round-trip a stale copy back into data["markdown_source"] on update_metadata.
+            if sanitized_data.is_a?(Hash) && sanitized_data.key?("markdown_source")
+              sanitized_data = sanitized_data.except("markdown_source")
+            end
             render json: {
               id: @creative.id,
               description: @creative.effective_description,
@@ -153,10 +163,12 @@ module Collavre
               depth: depth,
               prompt: @creative.prompt_for(Current.user),
               has_children: children_count > 0,
-              data: @creative.effective_origin(Set.new).data,
+              data: sanitized_data,
+              content_type: effective.data&.dig("content_type"),
+              markdown_source: can_edit ? effective.data&.dig("markdown_source") : nil,
               trigger_loop: trigger_loop_data,
               is_trigger_task: parent_trigger_enabled,
-              can_edit: @creative.has_permission?(Current.user, :write)
+              can_edit: can_edit
             }
           end
         end
@@ -190,7 +202,16 @@ module Collavre
       @creative = result.creative
 
       if result.success?
-        render json: { id: @creative.id }
+        # Expose the post-rewrite markdown source so the client can sync its
+        # textarea after the server replaces inline data: URIs with blob paths,
+        # matching the update endpoint contract. Without this, a freshly created
+        # markdown creative with a pasted data: URI would re-import the blob on
+        # the next keystroke save.
+        render json: {
+          id: @creative.id,
+          content_type: @creative.data&.dig("content_type"),
+          markdown_source: @creative.data&.dig("markdown_source")
+        }
       else
         render json: { errors: result.errors }, status: :unprocessable_entity
       end
@@ -259,8 +280,17 @@ module Collavre
               id: base.id,
               progress: base.progress,
               progress_html: view_context.render_creative_progress(base),
-              has_children: base.children.exists?
+              has_children: base.children.exists?,
+              content_type: base.data&.dig("content_type")
             }
+            # Expose the post-rewrite markdown source so the client can sync its
+            # textarea after the server replaces inline data: URIs with blob paths.
+            # Gated on write permission so a read-only share recipient moving a
+            # linked creative (parent_id-only PATCH bypasses the origin_changes
+            # write check) cannot read the origin's raw Markdown source.
+            if @creative.has_permission?(Current.user, :write)
+              response_data[:markdown_source] = base.data&.dig("markdown_source")
+            end
             # Build ancestor chain for progress updates (closure_tree: 1 SELECT via hierarchy table)
             ancestor_records = base.ancestors.order(:id)
             if ancestor_records.any?
@@ -359,6 +389,20 @@ module Collavre
         render json: { error: "Invalid JSON: #{e.message}" }, status: :unprocessable_entity
         return
       end
+      unless new_data.is_a?(Hash)
+        render json: { error: t("collavre.creatives.errors.metadata_must_be_object") }, status: :unprocessable_entity
+        return
+      end
+      # Reserved markdown fields are not editable via metadata; preserve current values so a stale
+      # YAML payload from the metadata popup can't overwrite a concurrent markdown edit.
+      current_data = creative.data || {}
+      %w[markdown_source content_type].each do |key|
+        if current_data.key?(key)
+          new_data[key] = current_data[key]
+        else
+          new_data.delete(key)
+        end
+      end
       previous_enabled = creative.drop_trigger_enabled?
 
       if creative.update(data: new_data)
@@ -499,7 +543,7 @@ module Collavre
       end
 
       def creative_params
-        params.require(:creative).permit(:description, :progress, :parent_id, :sequence, :origin_id)
+        params.require(:creative).permit(:description, :progress, :parent_id, :sequence, :origin_id, :markdown_source, :content_type_input)
       end
 
       def any_filter_active?

data/app/controllers/collavre/landing_controller.rb

@@ -0,0 +1,8 @@
+module Collavre
+  class LandingController < ApplicationController
+    allow_unauthenticated_access
+
+    def show
+    end
+  end
+end

data/app/controllers/collavre/passwords_controller.rb

@@ -20,6 +20,7 @@ module Collavre
 
     def update
       if @user.update(params.permit(:password, :password_confirmation))
+        @user.update_column(:email_verified_at, Time.current) unless @user.email_verified?
         redirect_to new_session_path, notice: "Password has been reset."
       else
         redirect_to edit_password_path(params[:token]), alert: "Passwords did not match."

data/app/controllers/collavre/public_assets_controller.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Collavre
+  # Serves ActiveStorage blobs through a CDN-friendly path:
+  #   /public-assets/blobs/:signed_id/*filename
+  #
+  # The signed_id is the only capability — no auth required. This makes the URL
+  # safe to embed in landing pages and other publicly-rendered HTML. CloudFront
+  # caches by full URL, so rotating signed_id (re-attach) invalidates effectively.
+  class PublicAssetsController < ActionController::Base
+    include ActiveStorage::SetCurrent
+    include ActiveStorage::Streaming
+
+    PUBLIC_CACHE_CONTROL = "public, max-age=31536000, immutable"
+
+    def show
+      blob = ActiveStorage::Blob.find_signed!(params[:signed_id])
+      response.headers["Cache-Control"] = PUBLIC_CACHE_CONTROL
+      send_blob_stream blob, disposition: "inline"
+    rescue ActiveSupport::MessageVerifier::InvalidSignature, ActiveRecord::RecordNotFound
+      head :not_found
+    end
+  end
+end

data/app/controllers/collavre/topics_controller.rb

@@ -3,7 +3,7 @@ module Collavre
     include Collavre::CreativePermissionGuard
 
     before_action :set_creative
-    before_action :require_creative_read!, only: %i[next_name]
+    before_action :require_creative_read!, only: %i[next_name channel_chips]
     before_action :require_creative_admin!, only: %i[update destroy move reorder]
     before_action :require_creative_write!, only: %i[create archive unarchive set_primary_agent]
 
@@ -12,8 +12,15 @@ module Collavre
       can_manage = @creative.has_permission?(Current.user, :admin) || is_owner
       can_create_topic = can_manage || @creative.has_permission?(Current.user, :write)
 
-      active_topics = @creative.topics.active.order(:created_at).to_a
-      preload_primary_agents(active_topics)
+      # Eagerly ensure Main (and System for inboxes) exist BEFORE loading
+      # active_topics. Otherwise the first inbox visit sees no System topic in
+      # the sidebar, and when a later notification creates it via
+      # find_or_create_by!, the unread badge appears but the user has no way to
+      # open the topic.
+      main_topic = @creative.main_topic(fallback_user: Current.user)
+      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
@@ -22,8 +29,8 @@ module Collavre
                           .pick(:last_topic_id)
       end
 
-      system_topic_id = @creative.inbox? ? @creative.topics.find_by(name: Creative::SYSTEM_TOPIC_NAME)&.id : nil
-      main_topic_id = @creative.main_topic(fallback_user: Current.user).id
+      system_topic_id = system_topic&.id
+      main_topic_id = main_topic.id
 
       render json: {
         topics: active_topics.map { |t| topic_json(t) },
@@ -33,7 +40,8 @@ module Collavre
         last_topic_id: last_topic_id,
         is_inbox: @creative.inbox?,
         system_topic_id: system_topic_id,
-        main_topic_id: main_topic_id
+        main_topic_id: main_topic_id,
+        effective_creative_id: @creative.id
       }
     end
 
@@ -73,6 +81,11 @@ module Collavre
       render json: { name: generate_next_topic_name }
     end
 
+    def channel_chips
+      topic = @creative.topics.find(params[:id])
+      render partial: "collavre/comments/channel_chips", locals: { topic: topic }
+    end
+
     def update
       topic = @creative.topics.find(params[:id])
 
@@ -194,32 +207,10 @@ module Collavre
       "#{prefix}#{next_number}"
     end
 
-    # Batch-load primary agents for all topics to avoid N+1 queries
-    def preload_primary_agents(topics)
-      topic_ids = topics.map(&:id)
-      return if topic_ids.empty?
-
-      policies = OrchestratorPolicy.where(
-        policy_type: "arbitration",
-        scope_type: "Topic",
-        scope_id: topic_ids
-      ).index_by { |p| p.scope_id.to_i }
-
-      agent_ids = policies.values.filter_map { |p| p.config&.dig("primary_agent_id") }
-      agents = agent_ids.present? ? User.where(id: agent_ids).includes(avatar_attachment: :blob).index_by(&:id) : {}
-
-      topics.each do |topic|
-        policy = policies[topic.id]
-        agent_id = policy&.config&.dig("primary_agent_id")
-        topic.instance_variable_set(:@_primary_agent, agents&.dig(agent_id))
-      end
-    end
-
     def topic_json(topic)
       data = topic.slice(:id, :name, :source_topic_id)
-      agent = topic.instance_variable_get(:@_primary_agent) || topic.primary_agent
-      if agent
-        data[:primary_agent] = agent_json(agent)
+      if topic.primary_agent
+        data[:primary_agent] = agent_json(topic.primary_agent)
       end
       data
     end

data/app/helpers/collavre/comments_helper.rb

@@ -5,5 +5,12 @@ module Collavre
     rescue JSON::ParserError, TypeError
       comment.action.to_s
     end
+
+    def comment_action_markdown(comment)
+      parsed = JSON.parse(comment.action)
+      parsed["markdown"] if parsed.is_a?(Hash) && parsed["markdown"].present?
+    rescue JSON::ParserError, TypeError
+      nil
+    end
   end
 end

data/app/helpers/collavre/public_assets_helper.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Collavre
+  module PublicAssetsHelper
+    # Returns a URL for serving an ActiveStorage blob through the public-assets
+    # proxy. When PUBLIC_ASSETS_HOST is set (e.g. CloudFront domain) the URL is
+    # absolute; otherwise relative so the browser uses the current host.
+    def public_asset_url(blob)
+      path = "/public-assets/blobs/#{blob.signed_id}/#{blob.filename.sanitized}"
+      host = Collavre::IntegrationSettings.fetch(:public_assets_host)
+      host ? "#{host.chomp('/')}#{path}" : path
+    end
+  end
+end

data/app/javascript/controllers/comment_controller.js

@@ -123,6 +123,15 @@ export default class extends Controller {
       }
     }
 
+    const actionMarkdownElement = this.element.querySelector('.comment-action-markdown')
+    if (actionMarkdownElement && actionMarkdownElement.dataset.rendered !== 'true') {
+      const text = actionMarkdownElement.textContent || ''
+      actionMarkdownElement.innerHTML = renderCommentMarkdown(text)
+      addTableDownloadButtons(actionMarkdownElement)
+      renderMermaidDiagrams(actionMarkdownElement)
+      actionMarkdownElement.dataset.rendered = 'true'
+    }
+
     // Text selection quote support
     this.handleMouseUp = this.handleMouseUp.bind(this)
     document.addEventListener('mouseup', this.handleMouseUp)

data/app/javascript/controllers/comments/form_controller.js

@@ -145,6 +145,10 @@ export default class extends Controller {
   onPopupOpened({ creativeId, canComment }) {
     this.creativeId = creativeId
     this.element.dataset.creativeId = creativeId || ''
+    // Stale topic ids from the previous creative are cleared by the popup
+    // controller BEFORE topics loadTopics() dispatches comments--topics:change,
+    // so by the time we get here, currentTopicId already reflects the new
+    // creative's restored topic. Do not re-clear it.
     this.formTarget.style.display = canComment ? '' : 'none'
     this.resetForm()
     if (canComment && this.shouldAutoFocusOnOpen()) {

data/app/javascript/controllers/comments/list_controller.js

@@ -1123,25 +1123,28 @@ export default class extends Controller {
   openActionEditor(container) {
     if (!container) return
     const json = container.querySelector('.comment-action-json')
+    const md = container.querySelector('.comment-action-markdown')
     const form = container.querySelector('.comment-action-edit-form')
     const btn = container.querySelector('.edit-comment-action-btn')
     const txt = form?.querySelector('.comment-action-edit-textarea')
-    if (json && form && txt) {
-      txt.value = json.textContent || ''
-      form.style.display = 'block'
-      if (btn) btn.style.display = 'none'
-      json.style.display = 'none'
-      txt.focus()
-    }
+    if (!form || !txt) return
+    if (json) txt.value = json.textContent || ''
+    form.style.display = 'block'
+    if (btn) btn.style.display = 'none'
+    if (json) json.style.display = 'none'
+    if (md) md.style.display = 'none'
+    txt.focus()
   }
 
   closeActionEditor(container) {
     if (!container) return
     const json = container.querySelector('.comment-action-json')
+    const md = container.querySelector('.comment-action-markdown')
     const form = container.querySelector('.comment-action-edit-form')
     const btn = container.querySelector('.edit-comment-action-btn')
     if (form) form.style.display = 'none'
     if (json) json.style.display = ''
+    if (md) md.style.display = ''
     if (btn) btn.style.display = ''
   }
 

data/app/javascript/controllers/comments/popup_controller.js

@@ -289,6 +289,15 @@ export default class extends Controller {
 
   async notifyChildControllers({ creativeId, canComment, highlightId }) {
     this.topicsController?.clearOverrideTopicId()
+    // Drop the previous creative's topic selection from the form controller
+    // synchronously, BEFORE topics loadTopics() dispatches `comments--topics:change`
+    // (which repopulates these via handleTopicChange). Doing it later — e.g. in
+    // formController.onPopupOpened, which runs after the topics await — would
+    // erase the topic that restoreSelection() just restored from the server.
+    if (this.formController) {
+      this.formController.currentTopicId = ''
+      this.formController._mainTopicId = null
+    }
     // Pre-set creativeId on list controller BEFORE loading topics.
     // Topics loading triggers a change event that list controller handles.
     // Without this, list controller still holds the previous creative's ID

data/app/javascript/controllers/comments/presence_controller.js

@@ -7,7 +7,7 @@ const TYPING_TIMEOUT = 3000
 const AGENT_STATUS_TIMEOUT = 10000 // Safety timeout for agent_status (heartbeat expected every 3s)
 
 export default class extends Controller {
-  static targets = ['participants', 'typingIndicator', 'textarea', 'privateCheckbox']
+  static targets = ['participants', 'typingIndicator', 'textarea', 'privateCheckbox', 'channelChips']
 
   connect() {
     this.creativeId = null
@@ -24,11 +24,13 @@ export default class extends Controller {
     this.handleInput = this.handleInput.bind(this)
     this.handleFocus = this.handleFocus.bind(this)
     this.handleBlur = this.handleBlur.bind(this)
+    this.handleTopicChange = this.handleTopicChange.bind(this)
 
     this.textareaTarget.addEventListener('input', this.handleInput)
     this.textareaTarget.addEventListener('focus', this.handleFocus)
     this.textareaTarget.addEventListener('blur', this.handleBlur)
     this.privateCheckboxTarget?.addEventListener('change', () => this.stoppedTyping())
+    this.element.addEventListener('comments--topics:change', this.handleTopicChange)
   }
 
   disconnect() {
@@ -36,6 +38,16 @@ export default class extends Controller {
     this.textareaTarget.removeEventListener('input', this.handleInput)
     this.textareaTarget.removeEventListener('focus', this.handleFocus)
     this.textareaTarget.removeEventListener('blur', this.handleBlur)
+    this.element.removeEventListener('comments--topics:change', this.handleTopicChange)
+  }
+
+  handleTopicChange(event) {
+    const topicId = event.detail?.topicId
+    if (topicId) {
+      this.refreshChannelChips(topicId)
+    } else {
+      this.clearChannelChips()
+    }
   }
 
   get listController() {
@@ -56,6 +68,23 @@ export default class extends Controller {
     this.subscribe()
     this.renderParticipants([])
     this.renderTypingIndicator()
+    // Bootstrap chips for the topic that is already active when the popup opens.
+    // Without this, chips only appear after a `topics:change` event fires
+    // (i.e. a topic switch) or after a webhook arrives — leaving the user
+    // unable to detach existing channels until something else triggers a paint.
+    this.bootstrapChannelChips()
+  }
+
+  bootstrapChannelChips() {
+    const topicsCtrl = this.application.getControllerForElementAndIdentifier(
+      this.element, 'comments--topics'
+    )
+    const topicId = topicsCtrl?.currentTopicId
+    if (topicId) {
+      this.refreshChannelChips(topicId)
+    } else {
+      this.clearChannelChips()
+    }
   }
 
   onPopupClosed() {
@@ -201,6 +230,9 @@ export default class extends Controller {
       this.loadParticipants({ closeOnForbidden: shareChange.has_access === false })
       return
     }
+    if (data.channel_chips) {
+      this.refreshChannelChips(data.channel_chips.topic_id)
+    }
     if (data.agent_status) {
       const { id, name, status, task_id, creative_id: agentCreativeId } = data.agent_status
       // Only show typing indicator if agent is working on this specific creative
@@ -417,6 +449,56 @@ export default class extends Controller {
       .catch((err) => console.warn('[presence] cancel agent task failed:', err))
   }
 
+  clearChannelChips() {
+    const target = this.hasChannelChipsTarget ? this.channelChipsTarget : null
+    if (!target) return
+    target.innerHTML = ''
+    delete target.dataset.topicId
+  }
+
+  refreshChannelChips(topicId) {
+    const target = this.hasChannelChipsTarget ? this.channelChipsTarget : null
+    if (!target) return
+    if (!this.creativeId) return
+    if (!topicId) {
+      this.clearChannelChips()
+      return
+    }
+
+    // Source of truth for "what the user is looking at" is the topics
+    // controller's currentTopicId, NOT the chip container's data-topic-id:
+    // - On initial popup open the container is empty (no data-topic-id),
+    //   so a stray broadcast for any topic in the same creative used to
+    //   paint chips for the wrong topic.
+    // - After the user switches topics the container's data-topic-id is
+    //   stale until something repaints it, blocking legit updates.
+    const topicsCtrl = this.application.getControllerForElementAndIdentifier(
+      this.element, 'comments--topics'
+    )
+    const activeTopicId = topicsCtrl?.currentTopicId || ''
+    if (String(activeTopicId) !== String(topicId)) return
+
+    fetch(`/creatives/${this.creativeId}/topics/${topicId}/channel_chips`, {
+      headers: { Accept: 'text/html' },
+      credentials: 'same-origin',
+    })
+      .then((r) => (r.ok ? r.text() : null))
+      .then((html) => {
+        if (html) target.outerHTML = html
+      })
+      .catch((err) => console.warn('[presence] refresh channel chips failed:', err))
+  }
+
+  detachChannel(event) {
+    const btn = event.currentTarget
+    const id = btn.dataset.channelId
+    if (!id) return
+    csrfFetch(`/channels/${id}`, {
+      method: 'DELETE',
+      headers: { Accept: 'application/json' },
+    }).catch((err) => console.warn('[presence] detach channel failed:', err))
+  }
+
   clearTypingTimers() {
     Object.values(this.typingTimers).forEach((timer) => clearTimeout(timer))
     this.typingTimers = {}

data/app/javascript/controllers/comments/topics_controller.js

@@ -34,6 +34,15 @@ export default class extends Controller {
 
     onPopupOpened({ creativeId }) {
         this.creativeIdValue = creativeId
+        // Clear stale cached state from the previous creative — otherwise
+        // chat-context autofill (command_menu) reads stale values during the
+        // window between popup switch and the new topics fetch completing.
+        // form_controller's currentTopicId is cleared upstream in
+        // popup_controller.notifyChildControllers; here we clear our own
+        // mainTopicId (read directly as the autofill fallback) and the cached
+        // effective_creative_id. loadTopics() repopulates both.
+        delete this.element.dataset.effectiveCreativeId
+        this.mainTopicId = null
         this.subscribe()
         return this.loadTopics()
     }
@@ -88,6 +97,12 @@ export default class extends Controller {
                 this.isInbox = !!data.is_inbox
                 this.systemTopicId = data.system_topic_id ? String(data.system_topic_id) : null
                 this.mainTopicId = data.main_topic_id ? String(data.main_topic_id) : null
+                // Expose effective origin id so chat-context autofill (slash commands)
+                // and any other consumer can target the same creative the server uses
+                // (linked creatives resolve params[:creative_id] through effective_origin).
+                if (data.effective_creative_id) {
+                    this.element.dataset.effectiveCreativeId = String(data.effective_creative_id)
+                }
 
                 // Migrate localStorage to server if server has no value
                 this.migrateLocalStorage()

data/app/javascript/controllers/creatives/__tests__/sync_controller.test.js

@@ -0,0 +1,89 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { jest } from '@jest/globals'
+
+const subscribeToCreatives = jest.fn()
+
+jest.unstable_mockModule('../../../services/creatives_channel', () => ({
+  subscribeToCreatives,
+}))
+
+const { Application } = await import('@hotwired/stimulus')
+const SyncController = (await import('../sync_controller')).default
+
+describe('CreativesSyncController subscribe timing', () => {
+  let application
+  let container
+
+  beforeEach(() => {
+    subscribeToCreatives.mockReset()
+    subscribeToCreatives.mockReturnValue({
+      cleanup: jest.fn(),
+      sendEditing: jest.fn(),
+      sendStoppedEditing: jest.fn(),
+    })
+
+    container = document.createElement('div')
+    container.id = 'sync-root'
+    container.setAttribute('data-controller', 'creatives--sync')
+    container.setAttribute('data-creatives--sync-root-id-value', '991')
+    document.body.appendChild(container)
+
+    application = Application.start()
+    application.register('creatives--sync', SyncController)
+  })
+
+  afterEach(() => {
+    application.stop()
+    document.body.innerHTML = ''
+  })
+
+  test('does NOT subscribe immediately when rootIdValue > 0 — waits for tree to load', async () => {
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(subscribeToCreatives).not.toHaveBeenCalled()
+  })
+
+  test('subscribes after creative-tree:updated event fires', async () => {
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    expect(subscribeToCreatives).not.toHaveBeenCalled()
+
+    container.dispatchEvent(
+      new CustomEvent('creative-tree:updated', { bubbles: true }),
+    )
+
+    expect(subscribeToCreatives).toHaveBeenCalledTimes(1)
+    expect(subscribeToCreatives).toHaveBeenCalledWith(991, expect.any(Object))
+  })
+
+  test('subscribes only once even if creative-tree:updated fires multiple times', async () => {
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    container.dispatchEvent(new CustomEvent('creative-tree:updated', { bubbles: true }))
+    container.dispatchEvent(new CustomEvent('creative-tree:updated', { bubbles: true }))
+    container.dispatchEvent(new CustomEvent('creative-tree:updated', { bubbles: true }))
+
+    expect(subscribeToCreatives).toHaveBeenCalledTimes(1)
+  })
+
+  test('subscribes immediately when tree is already loaded (Turbo cache restore)', async () => {
+    // Simulate Turbo restoring a cached tree page: data-loaded is already set
+    // before sync_controller connects, so tree_controller skips load() and
+    // never dispatches creative-tree:updated.
+    const cached = document.createElement('div')
+    cached.id = 'sync-cached'
+    cached.setAttribute('data-controller', 'creatives--cached-sync')
+    cached.setAttribute('data-creatives--cached-sync-root-id-value', '991')
+    cached.setAttribute('data-loaded', 'true')
+    cached.innerHTML = '<creative-tree-row creative-id="1"></creative-tree-row>'
+    document.body.appendChild(cached)
+
+    application.register('creatives--cached-sync', SyncController)
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(subscribeToCreatives).toHaveBeenCalledTimes(1)
+    expect(subscribeToCreatives).toHaveBeenCalledWith(991, expect.any(Object))
+  })
+})