chats 0.1.1 → 0.2.0

data/app/controllers/chats/messages_controller.rb

@@ -6,6 +6,11 @@ module Chats
     before_action :set_conversation
     before_action :set_message, only: %i[show update destroy]
     before_action :require_ownership!, only: %i[update destroy]
+    # A locked conversation refuses every write, not just new messages.
+    # `create` is NOT in this list: its own validation produces the same
+    # response, and going through the model keeps the "locked since you
+    # opened the composer" race in one place.
+    before_action :refuse_when_locked!, only: %i[update destroy]
 
     # Per-sender send throttle via Rails 8's built-in controller rate
     # limiting (https://api.rubyonrails.org/classes/ActionController/RateLimiting.html).
@@ -40,6 +45,17 @@ module Chats
           format.turbo_stream
           format.html { redirect_to conversation_path(@conversation) }
         end
+      elsif locked?
+        # The subject closed the conversation (Chats::ChatSubject#
+        # chat_locked?) — possibly while this composer sat open. Swap the
+        # composer for the locked notice instead of flashing an error at
+        # someone whose screen is now lying to them. 422, never a raise.
+        respond_to do |format|
+          format.turbo_stream { render :locked, status: :unprocessable_entity }
+          format.html do
+            redirect_to conversation_path(@conversation), alert: @conversation.locked_notice
+          end
+        end
       else
         respond_to do |format|
           format.turbo_stream { render :errors, status: :unprocessable_entity }
@@ -85,6 +101,24 @@ module Chats
       @conversation = find_conversation(params[:conversation_id])
     end
 
+    # Did THIS save fail because the conversation is locked? Reads the error
+    # type, not the conversation, so a message that also failed validation
+    # for another reason still reports that reason.
+    def locked?
+      @message.errors.of_kind?(:base, :locked)
+    end
+
+    # Gate the action, explain it in place: the composer becomes the locked
+    # notice (422), or a plain redirect carrying the notice without Turbo.
+    def refuse_when_locked!
+      return unless @conversation.locked?
+
+      respond_to do |format|
+        format.turbo_stream { render :locked, status: :unprocessable_entity }
+        format.html { redirect_to conversation_path(@conversation), alert: @conversation.locked_notice }
+      end
+    end
+
     def set_message
       @message = @conversation.messages.find(params[:id])
     end

data/app/controllers/chats/reactions_controller.rb

@@ -9,6 +9,7 @@ module Chats
     def create
       conversation = find_conversation(params[:conversation_id])
       message = conversation.messages.find(params[:message_id])
+      return refuse_when_locked(conversation) if conversation.locked?
 
       Chats::Reaction.toggle!(
         message: message,
@@ -29,5 +30,18 @@ module Chats
     rescue ActiveRecord::RecordInvalid
       head :unprocessable_entity
     end
+
+    private
+
+    # Same shape as the messages controller: swap the composer for the
+    # reason, 422, never an exception page.
+    def refuse_when_locked(conversation)
+      @conversation = conversation
+
+      respond_to do |format|
+        format.turbo_stream { render "chats/messages/locked", status: :unprocessable_entity }
+        format.html { redirect_to conversation_path(conversation), alert: conversation.locked_notice }
+      end
+    end
   end
 end

data/app/helpers/chats/engine_helper.rb

@@ -5,6 +5,17 @@ module Chats
   # HOST app's views (mixed into ActionView via the engine's on_load hook,
   # the same pattern the moderate gem uses for `report_link`).
   module EngineHelper
+    # Every slot the bundled views render, and the whole list of them. A
+    # host drops `app/views/chats/slots/_<name>.html.erb` in and it appears;
+    # a name that isn't here renders nothing.
+    SLOTS = %w[
+      inbox_top
+      inbox_empty
+      conversation_header_actions
+      locked_composer
+      message_meta
+    ].freeze
+
     # The "message this person" affordance for host pages — a listing, a
     # profile, an order. Renders nothing when there's no viewer, the viewer
     # IS the target, or policy/blocks forbid the pair, so it's always safe
@@ -126,6 +137,89 @@ module Chats
       end
     end
 
+    # --- Slots ----------------------------------------------------------------
+    #
+    # Named extension points the bundled views render WHEN a partial exists
+    # at `chats/slots/_<name>`. Hosts (and engines mounted on top of chats,
+    # like support_desk) drop a file in and it appears; nobody has to eject
+    # a whole screen to add one row or one button. Absent slots cost one
+    # memoized template lookup and render nothing.
+    #
+    #   app/views/chats/slots/_inbox_top.html.erb
+    #
+    # The slots: inbox_top, inbox_empty, conversation_header_actions,
+    # locked_composer, message_meta.
+    def chats_slot(name, **locals)
+      return unless chats_slot?(name)
+
+      render(partial: "chats/slots/#{name}", locals: locals)
+    end
+
+    # Whether a slot partial exists. Memoized per view instance, so a slot
+    # rendered inside a collection costs ONE lookup per request, not one per
+    # row. Anything outside SLOTS is ignored rather than looked up: the slot
+    # names are a contract, and a typo should render nothing instead of
+    # quietly becoming a new extension point nobody documented.
+    def chats_slot?(name)
+      key = name.to_s
+      return false unless Chats::EngineHelper::SLOTS.include?(key)
+
+      @chats_slots ||= {}
+      return @chats_slots[key] if @chats_slots.key?(key)
+
+      @chats_slots[key] = lookup_context.exists?("chats/slots/#{key}", [], true)
+    end
+
+    # --- Messager display -----------------------------------------------------
+
+    # Whether block/report affordances apply to this messager. False for
+    # `acts_as_messager blockable: false` (a support desk, a bot) — the
+    # bundled views hide the affordance instead of asking hosts to branch on
+    # class.
+    def chats_blockable?(messager)
+      Chats.blockable?(messager)
+    end
+
+    # A messager's profile URL per `config.messager_url`, or nil.
+    def chats_messager_url(messager)
+      Chats.messager_url_for(messager)
+    end
+
+    # A messager's name, linked to their profile when `config.messager_url`
+    # gives one and plain text when it doesn't — so the gem never renders a
+    # dead anchor or assumes a `user_path` exists.
+    def chats_messager_name(messager, css_class: nil)
+      name = Chats.display_name_for(messager)
+      url = chats_messager_url(messager)
+
+      url.present? ? link_to(name, url, class: css_class) : tag.span(name, class: css_class)
+    end
+
+    # The signature line under a signed message ("— Lucía G."), or nil.
+    def chats_message_signature(message)
+      Chats.message_signature_for(message)
+    end
+
+    # --- Grouped inbox rows ---------------------------------------------------
+
+    # Where a stacked inbox row goes: straight to the thread when the stack
+    # holds exactly one conversation, otherwise to the stack itself.
+    def chats_group_path(group)
+      return chats_routes.conversation_path(group.conversation) if group.single?
+
+      chats_group_path_for(group.messager)
+    end
+
+    # The stack list for a messager: the host's `group_path:` callable when
+    # `acts_as_messager` declared one (support_desk points it at its own
+    # screen), else chats' own filtered inbox.
+    def chats_group_path_for(messager)
+      custom = messager.class.try(:chat_group_path)
+      path = custom&.call(chats_viewer)
+
+      path.presence || chats_routes.conversations_path(with: Chats.inbox_with_sgid(messager))
+    end
+
     # The gem's bundled stylesheet (CSS-variable themed — see chats.css).
     # Called from the engine's own views; hosts that eject + restyle the
     # views with their own framework simply don't include it.

data/app/javascript/chats/refresh_inbox_controller.js

@@ -0,0 +1,86 @@
+import { Controller } from "@hotwired/stimulus"
+
+// chats--refresh-inbox — heals the inbox after a MISSED broadcast.
+//
+// The inbox updates via Turbo 8 page-refresh broadcasts
+// (Chats::Broadcasts.refresh_inbox_of → broadcast_refresh_later_to). Action
+// Cable has no replay: a refresh broadcast sent while this client's socket
+// was down (backgrounded tab/app, network blip, laptop asleep) is gone
+// forever, and the inbox silently sits at its last render until the user
+// happens to navigate. This controller re-runs the SAME page refresh on the
+// two moments we might have missed one — the socket reconnecting, and the
+// tab becoming visible again after long enough that the socket was reaped.
+//
+// It deliberately reuses chats--thread's reconnect/visibility detection (the
+// gem-native approach: observe the <turbo-cable-stream-source> `connected`
+// attribute rather than stand up a dedicated HeartbeatChannel — the attribute
+// IS the heartbeat). The difference is the recovery action: the thread does an
+// HTTP `?since=` delta because it patches messages surgically, whereas the
+// inbox already broadcasts whole-page refreshes, so the catch-up is just
+// `Turbo.session.refresh()` — idempotent, morphing, scroll-preserving.
+//
+// Registered automatically under the identifier "chats--refresh-inbox" via
+// the engine's importmap pin (see config/importmap.rb + Chats::Engine).
+//
+// Doctrine: Turbo Stream delivery is a best-effort enhancement; the page must
+// be correct without it. https://turbo.hotwired.dev/handbook/streams
+const REFRESH_AFTER_HIDDEN_MS = 60_000
+
+export default class extends Controller {
+  connect() {
+    this.streamDropped = false
+    this.hiddenAt = null
+    document.addEventListener("visibilitychange", this.visibilityChanged)
+    this.watchStreamSource()
+  }
+
+  disconnect() {
+    document.removeEventListener("visibilitychange", this.visibilityChanged)
+    this.sourceObserver?.disconnect()
+  }
+
+  visibilityChanged = () => {
+    if (document.visibilityState === "visible") {
+      // Hidden long enough that the socket may have been reaped → catch up
+      // on whatever the missed broadcasts would have refreshed.
+      if (this.hiddenAt && Date.now() - this.hiddenAt > REFRESH_AFTER_HIDDEN_MS) {
+        this.refresh()
+      }
+      this.hiddenAt = null
+    } else {
+      this.hiddenAt = Date.now()
+    }
+  }
+
+  // Reconnect detection without a dedicated cable channel: turbo-rails toggles
+  // a `connected` attribute on <turbo-cable-stream-source> as the Action Cable
+  // subscription confirms/drops, so observing it IS the heartbeat. A refresh
+  // that morphs the page can momentarily strip the attribute — harmless here:
+  // it only arms `streamDropped`, and the next genuine reconnect does one
+  // (cheap, idempotent) catch-up refresh.
+  watchStreamSource() {
+    const source = this.element.querySelector("turbo-cable-stream-source")
+    if (!source || typeof MutationObserver === "undefined") return
+
+    this.sourceObserver = new MutationObserver(() => {
+      const connected = source.hasAttribute("connected")
+      if (connected && this.streamDropped) {
+        this.streamDropped = false
+        this.refresh()
+      } else if (!connected) {
+        this.streamDropped = true
+      }
+    })
+    this.sourceObserver.observe(source, { attributes: true, attributeFilter: ["connected"] })
+  }
+
+  refresh() {
+    if (document.visibilityState !== "visible") return
+    // Don't morph the list out from under someone typing in the search box —
+    // the next trigger (or their own submit) will catch it up.
+    const active = document.activeElement
+    if (active && active.matches("input, textarea, select")) return
+
+    window.Turbo?.session?.refresh(document.baseURI)
+  }
+}

data/app/views/chats/conversations/_group.html.erb

@@ -0,0 +1,38 @@
+<%# One STACKED inbox row: every direct conversation the viewer has with a
+    `acts_as_messager inbox: :grouped` counterpart (a support desk, a
+    storefront), folded into a single line — their avatar and name, the
+    freshest message across the stack, and the aggregate unread badge.
+
+    A stack of one links straight to that thread (and the thread offers a
+    "see all" link back here); a deeper stack opens the stack list, which is
+    either the host's `group_path:` or chats' own filtered inbox. %>
+<li class="chats-row chats-row--group <%= "chats-row--unread" if group.unread? %>"
+    id="<%= group.dom_id %>">
+  <%= link_to chats_group_path(group), class: "chats-row__link" do %>
+    <%= chats_messager_avatar(group.messager) %>
+
+    <span class="chats-row__body">
+      <span class="chats-row__top">
+        <span class="chats-row__title"><%= group.title_for(viewer) %></span>
+        <time class="chats-row__time" datetime="<%= group.last_message_at&.iso8601 %>">
+          <%= chats_timestamp(group.last_message_at) %>
+        </time>
+      </span>
+
+      <% if group.open_count > 1 %>
+        <span class="chats-row__subject"><%= t("chats.inbox.group_count", count: group.open_count) %></span>
+      <% elsif group.conversation&.subject_label %>
+        <span class="chats-row__subject"><%= group.conversation.subject_label %></span>
+      <% end %>
+
+      <span class="chats-row__bottom">
+        <span class="chats-row__preview">
+          <%= group.conversation ? chats_preview_for(group.conversation, viewer) : "" %>
+        </span>
+        <% if group.unread? %>
+          <span class="chats-badge"><%= group.unread_count > 99 ? "99+" : group.unread_count %></span>
+        <% end %>
+      </span>
+    </span>
+  <% end %>
+</li>

data/app/views/chats/conversations/_locked_composer.html.erb

@@ -0,0 +1,15 @@
+<%# What sits where the composer would be when the conversation's SUBJECT
+    has locked it (Chats::ChatSubject#chat_locked?). It carries the same DOM
+    id as the composer form, so MessagesController#create can swap one for
+    the other with a single Turbo replace when a thread closes under an open
+    composer.
+
+    The `locked_composer` slot replaces the BODY (a reopen button, a link to
+    the closed ticket…) while keeping the id contract intact. %>
+<div id="<%= dom_id(conversation, :composer) %>" class="chats-composer chats-composer--locked">
+  <% if chats_slot?(:locked_composer) %>
+    <%= chats_slot :locked_composer, conversation: conversation, notice: conversation.locked_notice %>
+  <% else %>
+    <p class="chats-composer__locked-notice"><%= conversation.locked_notice %></p>
+  <% end %>
+</div>

data/app/views/chats/conversations/index.html.erb

@@ -1,16 +1,37 @@
 <%# The inbox. Subscribed to the viewer's inbox stream: new activity anywhere
     triggers a Turbo 8 page refresh (morphing, scroll-preserving), which
     re-renders this page per-viewer — see Chats::Broadcasts for why refreshes
-    beat surgical row patches here. %>
+    beat surgical row patches here.
+
+    Rows come from Chats::Inbox and are either a Chats::Conversation or a
+    Chats::InboxGroup (every direct thread with a `inbox: :grouped` messager,
+    stacked into one row).
+
+    The chats--refresh-inbox wrapper heals a MISSED refresh broadcast: Action
+    Cable has no replay, so a broadcast sent while the socket was down (tab
+    backgrounded, network blip) would leave the inbox stale until the user
+    navigated. The controller re-runs the same page refresh on cable reconnect
+    and on return-to-visible. It needs to wrap the <turbo-cable-stream-source>
+    that `turbo_stream_from` renders so it can observe its `connected`
+    attribute as the heartbeat. %>
 <%= chats_styles %>
-<%= turbo_stream_from chats_current_messager, :chats_inbox %>
+<div data-controller="chats--refresh-inbox">
+  <%= turbo_stream_from chats_current_messager, :chats_inbox %>
+</div>
 
 <div class="chats chats-inbox">
   <header class="chats-inbox__header">
     <h1 class="chats-inbox__title"><%= t("chats.inbox.title") %></h1>
   </header>
 
-  <% if Chats.config.search %>
+  <% if @inbox.filtered? %>
+    <p class="chats-inbox__filter">
+      <%= t("chats.inbox.filtered_by", name: Chats.display_name_for(@inbox.with)) %>
+      <%= link_to t("chats.inbox.clear_filter"), conversations_path, class: "chats-inbox__filter-clear" %>
+    </p>
+  <% end %>
+
+  <% if Chats.config.search && !@inbox.filtered? %>
     <%= form_with url: conversations_path,
           method: :get,
           class: "chats-search",
@@ -29,13 +50,21 @@
   <% end %>
 
   <%= turbo_frame_tag "chats_inbox_results", target: "_top" do %>
-    <% if @conversations.any? %>
+    <%# Slot: anything the host wants above the first row — a support door,
+        an announcement, a filter bar. Renders only when the partial exists. %>
+    <%= chats_slot :inbox_top, viewer: chats_current_messager, inbox: @inbox %>
+
+    <% if @rows.any? %>
       <ul class="chats-inbox__list">
-        <% @conversations.each do |conversation| %>
-          <%= render "chats/conversations/conversation_row",
-                conversation: conversation,
-                viewer: chats_current_messager,
-                unread_count: @unread_counts.fetch(conversation.id, 0) %>
+        <% @rows.each do |row| %>
+          <% if row.is_a?(Chats::InboxGroup) %>
+            <%= render "chats/conversations/group", group: row, viewer: chats_current_messager %>
+          <% else %>
+            <%= render "chats/conversations/conversation_row",
+                  conversation: row,
+                  viewer: chats_current_messager,
+                  unread_count: @unread_counts.fetch(row.id, 0) %>
+          <% end %>
         <% end %>
       </ul>
     <% elsif params[:q].present? %>
@@ -48,6 +77,7 @@
         <span class="chats-empty__icon" aria-hidden="true">💬</span>
         <p class="chats-empty__title"><%= t("chats.inbox.empty_title") %></p>
         <p class="chats-empty__hint"><%= t("chats.inbox.empty_hint") %></p>
+        <%= chats_slot :inbox_empty, viewer: chats_current_messager, inbox: @inbox %>
       </div>
     <% end %>
   <% end %>

data/app/views/chats/conversations/show.html.erb

@@ -19,6 +19,10 @@
       "chats--thread-refresh-url-value": refresh_conversation_path(@conversation),
       "chats--thread-thread-url-value": conversation_path(@conversation),
       "chats--thread-copied-label-value": t("chats.message.copied"),
+      # A plain data attribute (not a Stimulus value): host CSS/JS keys its
+      # own block/report affordances off it. False for a messager declared
+      # `acts_as_messager blockable: false`.
+      "chats-blockable": chats_blockable?(chats_counterpart),
       action: "pointerdown->chats--thread#pressStart pointermove->chats--thread#pressMove " \
               "pointerup->chats--thread#pressEnd pointercancel->chats--thread#pressCancel " \
               "contextmenu->chats--thread#contextMenu"
@@ -31,13 +35,33 @@
       <span aria-hidden="true">‹</span>
     <% end %>
 
-    <%= chats_conversation_avatar(@conversation, chats_current_messager) %>
+    <%# The counterpart is already resolved for the title, the profile link
+        and the stack link — reuse it here instead of asking again. %>
+    <% if chats_counterpart %>
+      <%= chats_messager_avatar(chats_counterpart) %>
+    <% else %>
+      <%= chats_conversation_avatar(@conversation, chats_current_messager) %>
+    <% end %>
 
     <div class="chats-thread__identity">
-      <h1 class="chats-thread__title"><%= @conversation.title_for(chats_current_messager) %></h1>
+      <h1 class="chats-thread__title">
+        <% if chats_counterpart %>
+          <%= chats_messager_name(chats_counterpart) %>
+        <% else %>
+          <%= @conversation.title_for(chats_current_messager) %>
+        <% end %>
+      </h1>
       <% if @conversation.subject_label %>
         <p class="chats-thread__subject"><%= @conversation.subject_label %></p>
       <% end %>
+      <%# A stacked counterpart's thread is one of many: offer the way back
+          to the whole stack (chats' filtered inbox, or the host's own
+          screen via `group_path:`). %>
+      <% if Chats.grouped_inbox?(chats_counterpart) %>
+        <p class="chats-thread__see-all">
+          <%= link_to t("chats.thread.see_all"), chats_group_path_for(chats_counterpart), class: "chats-thread__see-all-link" %>
+        </p>
+      <% end %>
     </div>
 
     <details class="chats-menu">
@@ -51,6 +75,15 @@
         <% if @conversation.group? %>
           <%= button_to t("chats.thread.leave"), leave_conversation_path(@conversation), method: :post, class: "chats-menu__item chats-menu__item--danger" %>
         <% end %>
+        <%# Slot: the host's own thread actions (block, report, archive…).
+            `blockable` is false for messagers declared
+            `acts_as_messager blockable: false`, so safety affordances
+            disappear against a support desk without any class check. %>
+        <%= chats_slot :conversation_header_actions,
+              conversation: @conversation,
+              viewer: chats_current_messager,
+              counterpart: chats_counterpart,
+              blockable: chats_blockable?(chats_counterpart) %>
       </div>
     </details>
   </header>
@@ -133,5 +166,13 @@
     </div>
   </div>
 
-  <%= render "chats/messages/composer", conversation: @conversation %>
+  <%# A locked conversation (its SUBJECT says so — Chats::ChatSubject#
+      chat_locked?) keeps its whole history readable and swaps the composer
+      for the reason it's closed. Never a hidden screen: gate the action,
+      explain it in place. %>
+  <% if @conversation.locked? %>
+    <%= render "chats/conversations/locked_composer", conversation: @conversation %>
+  <% else %>
+    <%= render "chats/messages/composer", conversation: @conversation %>
+  <% end %>
 <% end %>

data/app/views/chats/messages/_composer.html.erb

@@ -2,8 +2,12 @@
     the response — instant, no cable round-trip needed); the chats--composer
     controller adds autosize, desktop Enter-to-send, throttled typing pings,
     and reset-on-success. Plain form POST still works with JS disabled. %>
+<%# id: the swap target — a conversation that locks while this form is open
+    gets the locked notice rendered straight over it (see
+    chats/messages/locked.turbo_stream.erb). %>
 <%= form_with model: Chats::Message.new,
       url: conversation_messages_path(conversation),
+      id: dom_id(conversation, :composer),
       class: "chats-composer",
       data: {
         controller: "chats--composer",

data/app/views/chats/messages/_message.html.erb

@@ -27,7 +27,7 @@
   <% else %>
     <div class="chats-message__content">
       <% if message.conversation.group? && message.sender %>
-        <span class="chats-message__sender"><%= Chats.display_name_for(message.sender) %></span>
+        <%= chats_messager_name(message.sender, css_class: "chats-message__sender") %>
       <% end %>
 
       <div class="chats-message__bubble-row">
@@ -76,11 +76,20 @@
             <% end %>
           <% end %>
 
+          <%# Signature: who WROTE this, when that isn't who it was sent
+              from — an agent answering from a shared desk seat. The sender
+              stays the conversation identity; this line keeps the human
+              visible. See Chats::Message#signed?. %>
+          <% if (signature = chats_message_signature(message)) %>
+            <div class="chats-message__signature" data-chats-message-signature><%= signature %></div>
+          <% end %>
+
           <span class="chats-message__meta">
             <% if message.edited? && !message.deleted? %>
               <span class="chats-message__edited"><%= t("chats.message.edited") %></span>
             <% end %>
             <time datetime="<%= message.created_at.iso8601 %>"><%= message.created_at.in_time_zone.strftime("%H:%M") %></time>
+            <%= chats_slot :message_meta, message: message %>
             <% if Chats.config.read_receipts %>
               <span class="chats-message__receipt"
                     data-chats-message-receipt
@@ -95,6 +104,12 @@
       </div>
 
       <% unless message.deleted? %>
+        <%# A locked conversation (its SUBJECT says so) refuses every write —
+            new messages, edits, deletes and reactions alike. The server
+            enforces it; here we stop OFFERING what would only 422: existing
+            reactions still render, as plain counts instead of toggles, and
+            the long-press menu keeps only Copy. %>
+        <% locked = message.conversation.locked? %>
         <% reactions = Chats.config.reactions ? Chats::Reaction.summary_for(message) : [] %>
         <% if reactions.any? %>
           <div class="chats-message__reactions">
@@ -103,10 +118,16 @@
                 through the HOST's renderer where engine helpers don't exist
                 unqualified. See EngineHelper#chats_routes. %>
             <% reactions.each do |emoji, count| %>
-              <%= button_to chats_routes.conversation_message_reactions_path(message.conversation, message),
-                    method: :post, params: { emoji: emoji },
-                    class: "chats-reaction", "aria-label": t("chats.message.toggle_reaction", emoji: emoji) do %>
-                <%= emoji %><% if count > 1 %><span class="chats-reaction__count"><%= count %></span><% end %>
+              <% if locked %>
+                <span class="chats-reaction chats-reaction--locked">
+                  <%= emoji %><% if count > 1 %><span class="chats-reaction__count"><%= count %></span><% end %>
+                </span>
+              <% else %>
+                <%= button_to chats_routes.conversation_message_reactions_path(message.conversation, message),
+                      method: :post, params: { emoji: emoji },
+                      class: "chats-reaction", "aria-label": t("chats.message.toggle_reaction", emoji: emoji) do %>
+                  <%= emoji %><% if count > 1 %><span class="chats-reaction__count"><%= count %></span><% end %>
+                <% end %>
               <% end %>
             <% end %>
           </div>
@@ -122,7 +143,7 @@
             button_to forms keep working when cloned: the CSRF token is
             baked in at render time. %>
         <template data-chats-message-menu>
-          <% if Chats.config.reactions %>
+          <% if Chats.config.reactions && !locked %>
             <div class="chats-popup__reactions" role="group" aria-label="<%= t("chats.message.react") %>">
               <% %w[👍 ❤️ 😂 😮 😢 🙏].each do |emoji| %>
                 <%= button_to emoji, chats_routes.conversation_message_reactions_path(message.conversation, message),
@@ -137,12 +158,12 @@
                 <%= t("chats.message.copy") %>
               </button>
             <% end %>
-            <% if Chats.config.editing && message.body.present? %>
+            <% if Chats.config.editing && message.body.present? && !locked %>
               <button type="button" class="chats-popup__item" role="menuitem" data-chats-action="edit" data-chats-own-only>
                 <%= t("chats.message.edit") %>
               </button>
             <% end %>
-            <% if Chats.config.deletion %>
+            <% if Chats.config.deletion && !locked %>
               <%= button_to t("chats.message.delete"),
                     chats_routes.conversation_message_path(message.conversation, message),
                     method: :delete,

data/app/views/chats/messages/locked.turbo_stream.erb

@@ -0,0 +1,6 @@
+<%# The send landed on a conversation whose subject has since locked it.
+    Replace the composer with the locked notice (422) so the screen stops
+    lying to whoever had it open, and clear any stale error text. %>
+<%= turbo_stream.replace dom_id(@conversation, :composer) do %>
+  <%= render "chats/conversations/locked_composer", conversation: @conversation %>
+<% end %>

data/config/importmap.rb

@@ -8,9 +8,10 @@
 # "chats--composer", etc. with ZERO host JavaScript changes. (stimulus-rails,
 # app/assets/javascripts/stimulus-loading.js, registerControllerFromPath.)
 #
-# Hosts can override either controller by pinning the same key themselves —
+# Hosts can override any controller by pinning the same key themselves —
 # the engine's importmap is drawn FIRST (unshifted in Chats::Engine), and
 # importmap-rails resolves duplicate pins last-wins.
 pin "controllers/chats/thread_controller", to: "chats/thread_controller.js"
 pin "controllers/chats/composer_controller", to: "chats/composer_controller.js"
 pin "controllers/chats/debounced_submit_controller", to: "chats/debounced_submit_controller.js"
+pin "controllers/chats/refresh_inbox_controller", to: "chats/refresh_inbox_controller.js"

data/config/locales/en.yml

@@ -8,6 +8,11 @@ en:
       no_results_title: "No results"
       no_results_hint: "Nothing matched “%{query}”."
       no_messages: "No messages yet"
+      filtered_by: "Conversations with %{name}"
+      clear_filter: "Show all conversations"
+      group_count:
+        one: "1 conversation"
+        other: "%{count} conversations"
       you_prefix: "You:"
     thread:
       back: "Back"
@@ -22,6 +27,7 @@ en:
       yesterday: "Yesterday"
       typing_suffix: "is typing…"
       new_messages: "New messages"
+      see_all: "See all"
     conversation:
       empty_title: "Conversation"
     message:
@@ -30,6 +36,7 @@ en:
       copy: "Copy"
       copied: "Copied!"
       attachment: "Photo"
+      signature: "— %{name}"
       close_attachment: "Close photo"
       edit: "Edit"
       delete: "Delete"
@@ -44,6 +51,7 @@ en:
       placeholder: "Write a message…"
       send: "Send"
       attach: "Attach images"
+      locked: "This conversation is closed."
     buttons:
       chat: "Message"
     flashes:
@@ -67,7 +75,10 @@ en:
         chats/message:
           attributes:
             base:
+              locked: "This conversation is closed."
               blocked: "You can't message this person."
+            author:
+              not_a_messager: "must be a messager (acts_as_messager)"
             sender:
               blank: "is required"
               not_a_participant: "is not a participant of this conversation"