support_desk 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66ba1a32f86acca1b4068bbca4091fcb16c4e6840a9d57ae5dc44bea25572ea2
-  data.tar.gz: 2433e492636e42eeffde1652a2c7d21915267c6f0a9180bea8bb010d902cdfad
+  metadata.gz: afefc82399ac7abf6a331cc44fceb5fd160694fea8c83025af5e5888399a18d2
+  data.tar.gz: c209e7f207e89de6e4e0b48ecdd8b2dfd4e7011b352cf2eaf52c82dd9b13260f
 SHA512:
-  metadata.gz: ac1246120f4c2aa2763f81866006f054e0dfd14901d42120ddc25d754b08dad350b1627552faaa9e4fd62d37a50d785eeae9abe6dab1c5dc9adbb9f9bb44acd1
-  data.tar.gz: 66fca7c4ddad8c9b41358448ec24beda2a3dcd9bade8bd373fe7433a565700d500c212f863c1755048faa7dd803c79c1fa92d3fb0b029a072322d1eff6672994
+  metadata.gz: 773a60b0710143ef412597a9789b2c37e5a41d99cbb965e5908d6035c11dcd5d97b0353c4f0777e5fd1e7644414ad01afa7c19379402a83e3cb9ef81353d0896
+  data.tar.gz: 120b9347b36642f5248ba4c6e95b1898886f666913729cedc28d02b0177e3a97c5136e12ab8052501921a2b812488d55359ed326ac361dd5cb9c5af76b1ff55f

data/CHANGELOG.md

@@ -4,6 +4,83 @@ All notable changes to this project are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.0] - 2026-10-18
+
+### Added
+
+- **Support apart from the inbox.** `config.thread_page = :support` reads a
+  case on the engine's own page, `/support/tickets/T-AB12CD`, which renders
+  chats' thread template (same bubbles, composer and realtime) with its way
+  back leading to the support list. `support_thread_path`, the list rows and
+  the redirect after opening a case follow the setting. The default,
+  `:chats`, is unchanged. A third Hotwire Native rule pushes the ticket page
+  under `:support`.
+- **A requester's own case always opens through chats.** chats finds every
+  thread and composer request through `viewer.chats`, which applies the
+  host's `inbox_scope`; a host keeping support out of its inbox would 404 its
+  requesters inside their own cases. The engine adds the viewer's own cases
+  to chats' `conversation_lookup_scopes` (`SupportDesk::ConversationAccess`,
+  `SupportDesk::Ticket.conversations_of`): by participation and blocks,
+  without the listing scope, each a direct conversation whose subject is that
+  very case. Nothing else the scope hides becomes reachable.
+- **`acknowledgement`**, a desk setting: the system line posted right under a
+  requester's first message, in the same transaction, and read for them as
+  it is posted (a receipt for their own words is never news). Same values and
+  interpolations as `opening_line`; nil by default, and the gem ships
+  `support_desk.thread.acknowledgement` to opt into.
+- An I18n key given as a line reads its `<key>_with_promise` variant when the
+  desk promises a time and the variant exists (the assistant lines already
+  did): the shipped acknowledgement is "Thanks, we got it." on a desk with
+  `reply_within = nil`, and adds the promise otherwise.
+- `SupportDesk.humanize_promise` and `DeskConfiguration#reply_promise`: the
+  promise in the unit the desk wrote it in, from the new
+  `support_desk.durations.*` keys.
+- `support_desk.thread.closed_notice` can interpolate `%{reply_within}`,
+  `%{desk}` and `%{label}`.
+
+### Changed
+
+- The answer promise (`support_reply_promise`, the wizard's line, and
+  `%{reply_within}` in every line) is now said in the unit `reply_within`
+  was configured in: `24.hours` reads "24 hours" where it read "1 day", and
+  `8.hours` reads "8 hours" where it read "about 8 hours". A duration of more
+  than one unit, or a fractional one, reads as before. Waits in the console
+  are unchanged.
+
+### Fixed
+
+- `SupportDesk::ConversationAccess` adds a requester's own cases as a lookup
+  scope (`conversation_lookup_scopes`, chats 0.5.1) instead of rescuing chats'
+  404: no exception is inspected, and a host's own `find_conversation` that
+  refuses a case is final. It only ever adds a scope beside the host's: a host
+  that returns no scopes for a viewer (a suspended account) opens nothing for
+  them, their cases included.
+- The ticket page resolves its conversation through chats' own
+  `find_conversation` (a chats controller bound to the request), so whatever
+  refuses a case at the chats URL refuses it on the ticket page too.
+- The access fallback and the ticket page require the case and its
+  conversation to point at each other (a direct conversation whose subject is
+  that case): a ticket mislinked to a group or to another conversation opens
+  nothing.
+- The ticket page resolves its conversation through chats' participation and
+  block rules: owning the case is no longer enough once the seat is gone.
+- The support list's "showing the N most recent" line under a long closed
+  section (`support_desk.tickets.closed_capped`) had no copy in English or
+  Spanish, so a requester with more than 20 closed cases read "translation
+  missing".
+
+### Compatibility
+
+- Requires chats >= 0.5.1; take both from GitHub by tag until they are on
+  rubygems. (The old `~> 0.3, >= 0.3.2` already admitted 0.4 and 0.5: `~> 0.3`
+  is `>= 0.3, < 1.0`.) 0.5.1 brings the lookup seam the access to a
+  requester's own case is built on. The whole suite runs on chats 0.5.1, the
+  reviewed package in `vendor/cache` built from tag v0.5.1 (6159ea1). The
+  chats 0.4.2 CI leg is gone: the constraint no longer admits it. Every CI job
+  asserts the chats it resolved (`CHATS_VERSION_UNDER_TEST`), so a later chats
+  release never silently becomes what CI tests. The dummy app's chats
+  migration is chats' current install template.
+
 ## [0.3.2] - Unreleased
 
 ### Fixed

data/README.md

@@ -153,6 +153,7 @@ configuration mistake is a boot failure, never a 3 a.m. `NoMethodError`.
 | `current_agent_method` | `:current_user` | how the console finds the person answering (or define `current_agent` in your controller) |
 | `authenticate_method` | `:authenticate_user!` | your own filter, run before every requester screen |
 | `visible_desks_for` | `nil` (every desk) | `->(agent) { … }` returning the desks this agent may work; scopes the whole console |
+| `thread_page` | `:chats` | where a requester reads a case: `:chats` (its thread in the chats inbox) or `:support` (this engine's own ticket page, for support kept apart from the inbox; see [Support apart from the inbox](#support-apart-from-the-inbox)) |
 | `authorize_console` | `nil` (allow) | `->(agent, ticket, action) { … }`; asked before every console action, `ticket` is nil for `index`, `new`, `next` and `open_conversation`; a hook that raises **denies** |
 | `assistant(key) { … }` | — | declare an assistant (see [Assistants](#-assistants)); `config.assistants`, `config.assistant?(key)` read them back |
 | `default_assistant` | the only one declared | which assistant the `:default` desk gets when more than one exists |
@@ -185,7 +186,7 @@ SupportDesk.desk(:billing)  # another one (nil if nobody configured it)
 | `reply_policy` | `:anyone` | `:anyone` (a drop-in posts, signed; an unheld case is taken by whoever answers) · `:take_over` (replying reassigns) · `:assignee_only` (raises `NotAllowed`) |
 | `announce_assignments` | `:first_only` | `:first_only` ("Lucía is taking care of your request" once) · `:always` (hand-offs too) · `:never` |
 | `closed_tickets` | `:reopen_on_reply` | `:reopen_on_reply` (a requester writing reopens the case) · `:locked` (composer replaced by a notice) |
-| `reply_within` | `24.hours` | the SLA breach threshold **and** the promise the requester reads |
+| `reply_within` | `24.hours` | the SLA breach threshold **and** the promise the requester reads, said in the unit you write it in (`72.hours` reads "72 hours") |
 | `at_risk_after` | `4.hours` | when a waiting case starts showing as at risk |
 | `open_rate_limit` | `{ to: 5, within: 1.hour }` | how often one requester may **ask**; `nil` disables. Counts only cases the requester opened |
 | `max_open_tickets` | `5` | how many cases one requester may have open; `nil` disables. Same rule |
@@ -195,6 +196,7 @@ SupportDesk.desk(:billing)  # another one (nil if nobody configured it)
 | `auto_close_after` | `nil` | reserved for the sweep job: a duration after which an answered case closes itself |
 | `opening_line` | `nil` | the system line a requester-opened thread starts with (see [Writing first](#writing-first)) |
 | `opening_line_from_support` | the gem's I18n copy | the same line for a case the desk opened |
+| `acknowledgement` | `nil` | the system line posted right under a requester's first message ("Thanks, we got it…"; see [Writing first](#the-line-a-thread-opens-with)) |
 | `find_requester { \|query\| … }` | `nil` | how a console turns what an agent typed into a requester record |
 
 `SupportDesk.doctor.print` checks all of it against a running app (see
@@ -410,7 +412,7 @@ mount SupportDesk::Engine => "/support"   # CarHey mounts it at "/messages/suppo
 | `GET /support` | their cases — open ones as chats rows, closed ones folded away, and the door into a new one |
 | `GET /support/new` | the wizard: pick a topic, pick the thing, write. One URL, three Turbo frames |
 | `POST /support/tickets` | `ask_support!`, then straight into the conversation |
-| `GET /support/tickets/:id` | a stable URL for a case (`/support/tickets/T-AB12CD` works too), redirecting to its thread |
+| `GET /support/tickets/:id` | a stable URL for a case (`/support/tickets/T-AB12CD` works too): a redirect to its thread, or the page it is read on under `thread_page = :support` |
 
 The screens inherit `config.parent_controller`, so your layout, your
 authentication (`config.authenticate_method`) and your locale switching all
@@ -440,6 +442,54 @@ door in its place (`config.inbox_entry = :always | :when_tickets | :never`) —
 a support entry that only exists once you already have a ticket is
 undiscoverable.
 
+### Support apart from the inbox
+
+Some products want support to be a place of its own: a Support button that
+leads to the person's cases, rather than an official row among their
+conversations. Three settings say so:
+
+```ruby
+# config/initializers/support_desk.rb
+config.thread_page = :support     # a case is read at /support/tickets/T-AB12CD
+config.inbox_entry = :never       # no door in the chats inbox
+
+# config/initializers/chats.rb: support conversations out of the inbox, the unread badge and everything else that lists
+config.inbox_scope = ->(relation, _viewer) {
+  relation.where(subject_type: nil).or(relation.where.not(subject_type: "SupportDesk::Ticket"))
+}
+```
+
+(`subject_type: nil` keeps the conversations that are about nothing, which is
+most of them: `where.not` alone would hide those too.)
+
+The ticket page **is chats' thread**: the engine renders chats' own template,
+so the bubbles, the composer, read state, typing and realtime are the ones
+every other conversation has, with the desk's verified name in the header.
+Only the way back differs: it leads to the support list. Older pages, the
+composer and the live updates still go to chats' endpoints.
+
+Those endpoints find a conversation through the relations chats'
+`conversation_lookup_scopes` returns (chats >= 0.5.1), by default the viewer's
+inbox with the host's `inbox_scope` applied, so a scope that keeps support out
+of the inbox would also keep a requester out of their own case. The engine
+adds one relation after chats' own (`SupportDesk::ConversationAccess`): the
+viewer's **own** cases (`SupportDesk::Ticket.conversations_of`), through the
+same participation and block rules (`Chats::Conversation.inbox_for`) without
+the listing scope, each a direct conversation whose subject is that very
+case. Nobody gains a conversation they are not seated in, anything else the
+scope hides stays a 404, and a host's own `find_conversation` that refuses a
+case still refuses it. support_desk only ever adds a scope beside the host's:
+a host that must refuse a viewer entirely returns no scopes, and then nothing
+opens for them, their cases included. The ticket page asks chats the same
+question (chats' own `find_conversation`), so it never shows what the chats
+URL would refuse.
+
+Links follow the setting: `support_thread_path`, the list's rows and the
+redirect after a case is opened all lead to the ticket page, by reference.
+Telling the requester an answer arrived is then yours, since the chats
+badge no longer counts it: subscribe to `agent_replied` (see [Events](#events))
+and link the notification to `support_desk.ticket_path(ticket.reference)`.
+
 Hotwire Native hosts merge the engine's path rules into their own, AFTER any
 rule that could swallow them:
 
@@ -462,7 +512,7 @@ URL, so the back gesture and cold-boot deep links work.
 | `link_to_support(about:, text:, **html)` | the door into the wizard (nothing when there is nobody to ask, or nothing they may ask about) |
 | `support_unread_badge` | unread support messages, counted against the chats read horizon |
 | `support_desk_styles` | the bundled stylesheet tag for your `<head>` |
-| `support_reply_promise` | "We usually reply in under 24 hours", from `reply_within` |
+| `support_reply_promise` | "We usually reply in under 24 hours", from `reply_within` (also `SupportDesk.config.desk(key).reply_promise`) |
 | `support_ticket_state(ticket)` | "We're on it" · "We replied" · "We wrote to you" · "Closed" |
 | `support_inbox_door?(viewer)` | whether the inbox should show the door instead of a row (`inbox_entry`) |
 | `support_desk_record(key)`, `support_desk_avatar`, `support_desk_badge` | the desk as a counterpart: record, avatar (initials fallback), verified badge |
@@ -682,6 +732,33 @@ existing threads open exactly as they do today; `opening_line_from_support`
 has the gem's own copy as its default, because a message from a desk
 somebody never wrote to has to explain itself.
 
+And one line goes **under** the first message, for a case the requester
+opened: the answer to "did that go through?", posted in the same
+transaction, before anybody on the desk has read it.
+
+```ruby
+config.acknowledgement = :"support_desk.thread.acknowledgement"
+# => "Thanks, we got it. We usually reply in under 72 hours."
+```
+
+An I18n key reads its `<key>_with_promise` variant when the desk promises a
+time and the variant exists (the shipped key has one), so a desk with
+`reply_within = nil` says "Thanks, we got it." and nothing it cannot keep.
+The requester's read horizon moves through the acknowledgement as it is
+posted: it is a receipt for what they just wrote, never news to them.
+
+Same values and interpolations as the opening lines, nil by default. It
+never moves the clocks (it is a system message), it is pinned one database
+tick after the message when the clock did not move between the two inserts,
+and it is then the conversation's last message, which is what a list row
+previews. A reply into a case already open is not acknowledged again.
+
+`%{reply_within}` is the promise in the unit it was configured in
+(`SupportDesk.humanize_promise`: `72.hours` is "72 hours", never "3 days"),
+from `support_desk.durations.*`. The closed notice
+(`support_desk.thread.closed_notice`) takes the same three interpolations,
+so a locked case can say how soon a new one will be answered.
+
 ### From the console
 
 Add `new` to your routes and the queue grows a "Write to someone" button:
@@ -1674,7 +1751,8 @@ SupportDesk.find_topic("billing/invoice")
 SupportDesk.on(event, key: nil) { … }  SupportDesk.off(event, key)
 SupportDesk.doctor
 SupportDesk.native_path_rules(mount:, title:)   # Hotwire Native path rules for the requester screens
-SupportDesk.humanize_duration(24.hours)          # "1 day", in the reader's language
+SupportDesk.humanize_duration(24.hours)          # "1 day", in the reader's language (a wait: rounded)
+SupportDesk.humanize_promise(72.hours)           # "72 hours" (a promise: in the unit it was made in)
 SupportDesk.actor_key(record)                    # a stable key for an actor (GlobalID param); what event payloads store
 SupportDesk.requester_class?(klass)  .supportable_class?(klass)  .agent_class?(klass)
 SupportDesk.eligible?(record, condition)         # how both macros read their `if:`
@@ -1686,7 +1764,7 @@ SupportDesk::VERSION
 
 After checking out the repo, run `bundle install`, then `bundle exec rake ci`. The dummy app lives in `test/dummy` and mounts all three surfaces the way a real host does: the requester engine at `/messages/support`, `chats` at `/messages`, and the turnkey console at `/admin/support` — plus the same console again inside a host-owned `madmin` namespace, because "the console uses only the public API" is a claim that needs a second implementation to be worth anything.
 
-`chats` is the kernel this gem is a product on and the two are developed in lockstep, so the Gemfile points at a sibling checkout (`../chats`) whenever this gem needs a `chats` that is not on rubygems yet. It currently requires `chats` ~> 0.3 (the `verified:` messager option).
+`chats` is the kernel this gem is a product on and the two are developed in lockstep. support_desk requires `chats >= 0.5.1, < 1.0`. Until that is on rubygems, the bundle takes the reviewed chats package from `vendor/cache` (provenance and checksum in `vendor/cache/README.md`), so `bundle exec rake ci` needs no network and no sibling checkout.
 
 ## Contributing
 

data/app/controllers/support_desk/application_controller.rb

@@ -81,10 +81,13 @@ module SupportDesk
       respond_to?(:chats) ? chats : Chats::Engine.routes.url_helpers
     end
 
-    # Where a case is read and answered: its chats conversation, never a
-    # second thread UI of our own.
+    # Where a case is read and answered: its chats conversation, in the
+    # chats inbox (`thread_page = :chats`) or on this engine's ticket page
+    # (`:support`). Never a second thread UI of our own: that page renders
+    # chats' thread.
     def conversation_path_for(ticket)
       return root_path if ticket.conversation.nil?
+      return ticket_path(ticket.reference) if SupportDesk.config.support_thread_page?
 
       chats_routes.conversation_path(ticket.conversation)
     end

data/app/controllers/support_desk/tickets_controller.rb

@@ -16,6 +16,11 @@ module SupportDesk
     before_action :set_wizard, only: %i[new create]
     include Chats::SendRateLimited
 
+    # The ticket page renders chats' thread template, which names chats'
+    # routes bare (SupportDesk::ThreadHelper) and asks for these two.
+    helper SupportDesk::ThreadHelper
+    helper_method :chats_current_messager, :chats_counterpart
+
     # Their cases: open ones as rows, closed ones folded away, and the door
     # to open another.
     def index
@@ -67,10 +72,15 @@ module SupportDesk
     end
 
     # A stable URL for a case — what an email or a push notification links
-    # to. The case is READ in its conversation, so this is a redirect and
-    # nothing else.
+    # to. Under `thread_page = :chats` the case is read in the inbox's thread,
+    # so this is a redirect and nothing else. Under `:support` it is the page
+    # the case is read on: chats' own thread, with its back link leading
+    # here rather than to an inbox support is not part of.
     def show
-      redirect_to conversation_path_for(find_ticket)
+      ticket = find_ticket
+      return redirect_to conversation_path_for(ticket) unless SupportDesk.config.support_thread_page? && ticket.conversation
+
+      render_thread(ticket)
     end
 
     # "Prefiero hablar con una persona." The one thing a requester can
@@ -96,6 +106,61 @@ module SupportDesk
 
     def chat_rate_limit_messager = current_requester
 
+    # chats' thread page, rendered here: the same latest page of messages,
+    # the same «new messages» line and the same read on open as
+    # Chats::ConversationsController#show, for chats' own template. Older
+    # pages, the composer and the live updates are chats' endpoints, which
+    # reach this conversation through SupportDesk::ConversationAccess.
+    def render_thread(ticket)
+      @ticket = ticket
+      @conversation = chats_conversation(ticket)
+      @participant = @conversation.participant_for(current_requester)
+
+      scope = @conversation.messages.includes(:sender, :reactions)
+      scope = scope.with_attached_files if scope.respond_to?(:with_attached_files)
+      page = scope.recent_first.limit(Chats.config.messages_per_page + 1).to_a
+      @more_messages = page.size > Chats.config.messages_per_page
+      @messages = page.first(Chats.config.messages_per_page).reverse
+
+      if @participant&.unread?
+        @first_unread_id = @participant.unread_messages.where(id: @messages.map(&:id)).oldest_first.pick(:id) ||
+                           @messages.first&.id
+      end
+      # A pointer resting on a link (Turbo's hover prefetch) is not somebody
+      # reading the case; the visit that follows reads it. Read through the
+      # last message on the page, not merely "now": an acknowledgement pinned
+      # one tick after the message it answers may sit just ahead of the clock.
+      @participant&.read!(at: [ Time.current, @messages.last&.created_at ].compact.max) unless prefetch_request?
+
+      render :show
+    end
+
+    # The case's conversation, as chats' own endpoints would find it: chats'
+    # `find_conversation` on a chats controller bound to this request, so
+    # every rule the host or a product gem added there (its lookup scopes, its
+    # own `find_conversation`) decides here exactly as at the chats URL. Then
+    # it must be this very case's conversation: direct, about this case (the
+    # rule Ticket.conversations_of holds the chats lookup to). A 404
+    # otherwise, never a hint.
+    def chats_conversation(ticket)
+      lookup = Chats::ApplicationController.new
+      lookup.set_request!(request)
+      conversation = lookup.send(:find_conversation, ticket.conversation_id)
+      raise ActiveRecord::RecordNotFound unless conversation.direct? &&
+                                                conversation.subject_type == ticket.class.polymorphic_name &&
+                                                conversation.subject_id.to_s == ticket.id.to_s
+
+      conversation
+    end
+
+    def prefetch_request?
+      request.headers["X-Sec-Purpose"] == "prefetch" || request.headers["Sec-Purpose"].to_s.include?("prefetch")
+    end
+
+    # What chats' thread template asks its controller for.
+    def chats_current_messager = current_requester
+    def chats_counterpart = @conversation&.counterpart_for(current_requester)
+
     def set_wizard
       @wizard = SupportDesk::Wizard.new(current_requester, params)
       # A token that is forged, expired, or points at somebody else's record

data/app/helpers/support_desk/engine_helper.rb

@@ -84,14 +84,11 @@ module SupportDesk
       content_for(:head) { stylesheet_link_tag "support_desk", "data-turbo-track": "reload" }
     end
 
-    # "Normalmente respondemos en menos de 24 h" for a desk, or nil when the
-    # desk promises nothing. The same `config.reply_within` the SLA breaches
-    # on — one setting, one truth.
+    # "Normalmente respondemos en menos de 24 horas" for a desk, or nil when
+    # the desk promises nothing. The same `config.reply_within` the SLA
+    # breaches on — one setting, one truth.
     def support_reply_promise(desk_key = :default)
-      within = SupportDesk.config.desk(desk_key).reply_within
-      return nil if within.nil?
-
-      t("support_desk.thread.promise", time: SupportDesk.humanize_duration(within))
+      SupportDesk.config.desk(desk_key).reply_promise
     end
 
     # The status line under a case in the requester's list: who owes the next
@@ -178,10 +175,13 @@ module SupportDesk
       chats_verified_badge(support_desk_record(desk_key))
     end
 
-    # Where a case is read and answered: its chats conversation. Falls back
-    # to the engine's own ticket URL (which redirects to the same place) for
-    # the one case that has no conversation yet, so a link is never dead.
+    # Where a case is read and answered: its chats conversation, or the
+    # engine's own ticket page under `thread_page = :support` (by reference:
+    # the URL people read back from a screen). Falls back to the ticket URL
+    # (which redirects to the same place) for the one case that has no
+    # conversation yet, so a link is never dead.
     def support_thread_path(ticket)
+      return support_desk_routes.ticket_path(ticket.reference) if SupportDesk.config.support_thread_page?
       return support_desk_routes.ticket_path(ticket) if ticket.conversation.nil? || !respond_to?(:chats_routes)
 
       chats_routes.conversation_path(ticket.conversation)

data/app/helpers/support_desk/thread_helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SupportDesk
+  # The ticket page (`config.thread_page = :support`) renders chats' own
+  # thread template, and that template names chats' routes bare:
+  # `conversation_path`, `read_conversation_path`,
+  # `conversation_messages_path`… Inside chats' engine those are its own;
+  # rendered from this engine they would be looked up here and not exist.
+  #
+  # So on that page any route helper this engine does not have is chats',
+  # through its mounted proxy (`chats_routes`), and the one name both
+  # engines draw stays ours: `root_path` is the support list, which is
+  # exactly where the thread's way back should lead.
+  module ThreadHelper
+    def method_missing(name, ...)
+      chats_route?(name) ? chats_routes.public_send(name, ...) : super
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      chats_route?(name) || super
+    end
+
+    private
+
+    def chats_route?(name)
+      name.end_with?("_path", "_url") && chats_routes.respond_to?(name)
+    end
+  end
+end

data/app/views/support_desk/tickets/show.html.erb

@@ -0,0 +1,8 @@
+<%# One case, read where support lives (`config.thread_page = :support`).
+
+    It is chats' thread: the same template, so the same bubbles, composer,
+    read state and live updates as every conversation in the app, with the
+    desk's verified name in its header. Only the way back differs: its
+    `root_path` is this engine's, the support list (SupportDesk::ThreadHelper).
+    Eject this file to put anything of your own around it. %>
+<%= render template: "chats/conversations/show" %>

data/config/locales/support_desk.en.yml

@@ -14,12 +14,37 @@ en:
       closed_notice: "This conversation is closed. Start a new one if you need anything else."
       reopened_notice: "We reopened this conversation."
       promise: "We usually reply in under %{time}"
+      acknowledgement: "Thanks, we got it."
+      acknowledgement_with_promise: "Thanks, we got it. We usually reply in under %{reply_within}."
       opened_by_support: "%{desk} opened this conversation with you about “%{label}”. You can reply right here."
       unavailable_notice: "This account can no longer send or receive messages. The conversation stays here to read."
       human_door: "I’d rather talk to a person"
       human_requested_notice: "Done. Somebody from the team will take it from here."
       handled_by_assistant: "Handled by %{name}"
       handled_by_humans: "Somebody from the team will take it from here"
+    # The answer promise, in the unit the desk wrote it in (SupportDesk.humanize_promise).
+    durations:
+      seconds:
+        one: "1 second"
+        other: "%{count} seconds"
+      minutes:
+        one: "1 minute"
+        other: "%{count} minutes"
+      hours:
+        one: "1 hour"
+        other: "%{count} hours"
+      days:
+        one: "1 day"
+        other: "%{count} days"
+      weeks:
+        one: "1 week"
+        other: "%{count} weeks"
+      months:
+        one: "1 month"
+        other: "%{count} months"
+      years:
+        one: "1 year"
+        other: "%{count} years"
     transcript:
       deleted: "[message deleted]"
     notifications:
@@ -55,6 +80,9 @@ en:
       closed_section:
         one: "1 closed conversation"
         other: "%{count} closed conversations"
+      closed_capped:
+        one: "Showing the most recent one."
+        other: "Showing the %{count} most recent."
       state:
         awaiting_reply: "We're on it"
         answered: "We replied"

data/config/locales/support_desk.es.yml

@@ -19,6 +19,8 @@ es:
       closed_notice: "Esta conversación está cerrada. Abre una nueva si necesitas algo más."
       reopened_notice: "Hemos vuelto a abrir esta conversación."
       promise: "Normalmente respondemos en menos de %{time}"
+      acknowledgement: "Gracias, lo hemos recibido."
+      acknowledgement_with_promise: "Gracias, lo hemos recibido. Normalmente respondemos en menos de %{reply_within}."
       # La línea con la que se abre un hilo que ha empezado el equipo: quien
       # recibe un mensaje de un sitio al que nunca ha escrito necesita saber
       # qué es esto.
@@ -28,6 +30,29 @@ es:
       human_requested_notice: "Hecho. Una persona del equipo seguirá con tu consulta."
       handled_by_assistant: "Atendida por %{name}"
       handled_by_humans: "Una persona del equipo seguirá con tu consulta"
+    # La promesa de respuesta, en la unidad en que la escribió la mesa (SupportDesk.humanize_promise).
+    durations:
+      seconds:
+        one: "1 segundo"
+        other: "%{count} segundos"
+      minutes:
+        one: "1 minuto"
+        other: "%{count} minutos"
+      hours:
+        one: "1 hora"
+        other: "%{count} horas"
+      days:
+        one: "1 día"
+        other: "%{count} días"
+      weeks:
+        one: "1 semana"
+        other: "%{count} semanas"
+      months:
+        one: "1 mes"
+        other: "%{count} meses"
+      years:
+        one: "1 año"
+        other: "%{count} años"
     transcript:
       # Un mensaje borrado sigue siendo un turno. Quien lea la conversación
       # después, una persona o el modelo al que el host se la pasa, tiene
@@ -70,6 +95,9 @@ es:
       closed_section:
         one: "1 conversación cerrada"
         other: "%{count} conversaciones cerradas"
+      closed_capped:
+        one: "Se muestra la más reciente."
+        other: "Se muestran las %{count} más recientes."
       state:
         awaiting_reply: "Estamos con ello"
         answered: "Te hemos contestado"

data/lib/generators/support_desk/templates/initializer.rb

@@ -61,6 +61,18 @@ SupportDesk.configure do |config|
   # screen, so a logged-out visitor meets YOUR login flow.
   #
   # config.authenticate_method = :authenticate_user!
+  #
+  # Where a case is read:
+  #   :chats    in the chats inbox's own thread (/messages/:id), with the
+  #             desk as one grouped row there
+  #   :support  on this engine's own page (/support/tickets/T-AB12CD): a
+  #             support area of its own, for a host that keeps support out
+  #             of the inbox (`inbox_entry = :never`, and a chats
+  #             `inbox_scope` that leaves SupportDesk::Ticket conversations
+  #             out). The thread is still chats': its bubbles, composer and
+  #             realtime, on a page whose way back leads here.
+  #
+  # config.thread_page = :chats
 
   # ==========================================================================
   # THE DESK
@@ -135,6 +147,13 @@ SupportDesk.configure do |config|
   # config.opening_line = "Has abierto una conversación sobre «%{label}». Te contestamos aquí."
   # config.opening_line_from_support = "%{desk} ha abierto esta conversación contigo sobre «%{label}»."
   #
+  # The line posted right UNDER a requester's first message ("Thanks, we got
+  # it. We usually reply in under 72 hours."): the answer to "did that go
+  # through?", before anybody has read it. Same values and interpolations as
+  # the opening line; nil (the default) posts nothing. The gem ships one:
+  #
+  # config.acknowledgement = :"support_desk.thread.acknowledgement"
+  #
   # What a requester writing into a closed ticket does:
   #   :reopen_on_reply  the case comes back (no wall, no dead end)
   #   :locked           the composer is replaced by a notice
@@ -143,7 +162,8 @@ SupportDesk.configure do |config|
   #
   # The answer promise: the SLA breach threshold AND the line requesters are
   # shown when they write ("normalmente en menos de 24 h"). One setting, one
-  # truth. `at_risk_after` is the earlier, softer warning for the queue.
+  # truth, said in the unit you write it in (72.hours reads "72 hours").
+  # `at_risk_after` is the earlier, softer warning for the queue.
   #
   # config.reply_within = 24.hours
   # config.at_risk_after = 4.hours

data/lib/support_desk/brief.rb

@@ -109,7 +109,7 @@ module SupportDesk
       {
         key: desk&.key,
         name: desk&.name,
-        reply_within: (SupportDesk.humanize_duration(reply_within) if reply_within)
+        reply_within: (SupportDesk.humanize_promise(reply_within) if reply_within)
       }
     end
 

data/lib/support_desk/configuration.rb

@@ -65,6 +65,7 @@ module SupportDesk
         # this one has a default and `opening_line` does not: existing hosts'
         # threads keep opening exactly as they do today.
         opening_line_from_support: :"support_desk.thread.opened_by_support",
+        acknowledgement: nil,
         find_requester: nil,
         reply_policy: :anyone,
         announce_assignments: :first_only,
@@ -166,6 +167,28 @@ module SupportDesk
         @settings[:opening_line_from_support] = ensure_line(value, "opening_line_from_support")
       end
 
+      # The system line posted right UNDER a requester's first message, in the
+      # same transaction: "Thanks, we got it. We usually reply in under 72
+      # hours." The answer to "did that go through?", said where they are
+      # looking, before anybody on the desk has read it. Only for a case the
+      # requester opened; a case the desk opens starts with
+      # `opening_line_from_support` instead.
+      #
+      # Same values as `opening_line`, and the same interpolations. nil (the
+      # default) posts nothing; the gem ships a line to opt into:
+      #
+      #   config.acknowledgement = :"support_desk.thread.acknowledgement"
+      def acknowledgement(&block)
+        return @settings[:acknowledgement] = block if block
+
+        read(:acknowledgement)
+      end
+
+      # Set it, validating on assignment (see the reader above).
+      def acknowledgement=(value)
+        @settings[:acknowledgement] = ensure_line(value, "acknowledgement")
+      end
+
       # How a console finds the person an agent types: email, phone, handle,
       # whatever this host lets staff search by. Given the typed string,
       # returns a requester record or nil.
@@ -192,7 +215,7 @@ module SupportDesk
       # it needs a ticket, and running a host's callback as a diagnostic is
       # not a diagnostic.
       def opening_line_problems # :nodoc:
-        %i[opening_line opening_line_from_support].filter_map do |setting|
+        %i[opening_line opening_line_from_support acknowledgement].filter_map do |setting|
           value = public_send(setting)
           next if value.nil? || value.respond_to?(:call)
 
@@ -214,22 +237,46 @@ module SupportDesk
       # What to post for THIS ticket, resolved and interpolated in the
       # current locale. nil or blank means post nothing.
       def opening_line_for(ticket)
-        setting = ticket.opened_by_support? ? opening_line_from_support : opening_line
-        return nil if setting.nil?
-
-        line = case setting
-        when Symbol then I18n.t(setting, **line_interpolations(ticket), raise: true)
-        when String then interpolate_line(setting, line_interpolations(ticket), "opening_line")
-        else setting.call(ticket)
+        if ticket.opened_by_support?
+          line_for(ticket, opening_line_from_support, "opening_line_from_support")
+        else
+          line_for(ticket, opening_line, "opening_line")
         end
-        return nil if line.nil?
+      end
 
-        unless line.is_a?(String)
-          raise ConfigurationError,
-                "an opening_line block must return a String or nil, got #{line.inspect}"
-        end
+      # The acknowledgement for THIS ticket, the same way: nil for a case the
+      # desk opened, and nil or blank means post nothing.
+      def acknowledgement_for(ticket)
+        return nil if ticket.opened_by_support?
 
-        line
+        line_for(ticket, acknowledgement, "acknowledgement")
+      end
+
+      # "We usually reply in under 72 hours", in the current locale, or nil
+      # when this desk promises nothing. The line the requester reads above
+      # the composer and on the door, from the same `reply_within` the SLA
+      # breaches on.
+      def reply_promise
+        within = reply_within
+        return nil if within.nil?
+
+        I18n.t("support_desk.thread.promise", time: SupportDesk.humanize_promise(within))
+      end
+
+      # What every line and notice of this desk can say about +ticket+:
+      # %{label}, %{desk} and %{reply_within} (the promise, in its own unit).
+      def line_interpolations(ticket)
+        { label: ticket.label, desk: ticket.desk.name,
+          reply_within: (SupportDesk.humanize_promise(reply_within) if reply_within) }
+      end
+
+      # The `_with_promise` variant of an I18n key, when this desk promises a
+      # time and the variant exists; the key as written otherwise.
+      def promised_key(symbol)
+        return symbol if reply_within.nil?
+
+        promised = :"#{symbol}_with_promise"
+        I18n.exists?(promised) ? promised : symbol
       end
 
       # --- Who answers ----------------------------------------------------------
@@ -554,9 +601,24 @@ module SupportDesk
               "#{LINE_INTERPOLATIONS.keys.map { |key| "%{#{key}}" }.join(", ")}."
       end
 
-      def line_interpolations(ticket)
-        { label: ticket.label, desk: ticket.desk.name,
-          reply_within: (SupportDesk.humanize_duration(reply_within) if reply_within) }
+      # One configured line, resolved and interpolated for +ticket+. An I18n
+      # key reads its `<key>_with_promise` variant when this desk promises a
+      # time and the variant exists, so a desk with `reply_within = nil` never
+      # says "we usually reply in under ." (the gem's assistant lines work the
+      # same way).
+      def line_for(ticket, setting, name)
+        return nil if setting.nil?
+
+        line = case setting
+        when Symbol then I18n.t(promised_key(setting), **line_interpolations(ticket), raise: true)
+        when String then interpolate_line(setting, line_interpolations(ticket), name)
+        else setting.call(ticket)
+        end
+        return nil if line.nil?
+
+        raise ConfigurationError, "a #{name} block must return a String or nil, got #{line.inspect}" unless line.is_a?(String)
+
+        line
       end
     end
 
@@ -949,7 +1011,7 @@ module SupportDesk
       def line_interpolations(ticket)
         reply_within = ticket.desk_config.reply_within
         { name: name, desk: ticket.desk.name,
-          reply_within: (SupportDesk.humanize_duration(reply_within) if reply_within) }
+          reply_within: (SupportDesk.humanize_promise(reply_within) if reply_within) }
       end
     end
 
@@ -957,7 +1019,7 @@ module SupportDesk
     # top-level accessors forward to the `:default` desk, which is also what
     # every other desk falls back to.
     DESK_SETTINGS = %i[
-      name avatar email opening_line opening_line_from_support find_requester reply_policy
+      name avatar email opening_line opening_line_from_support acknowledgement find_requester reply_policy
       announce_assignments closed_tickets reply_within at_risk_after open_rate_limit max_open_tickets
       inbox_entry routing mirror_replies_by_email auto_close_after assistant
     ].freeze
@@ -999,6 +1061,12 @@ module SupportDesk
     # own. Read through #console_authorized?.
     attr_reader :authorize_console
 
+    # Where a requester reads a case: :chats (the default) is its
+    # conversation in the chats inbox; :support is this engine's own ticket
+    # page, for a host whose support lives apart from its inbox.
+    THREAD_PAGES = %i[chats support].freeze
+    attr_reader :thread_page
+
     # A fresh configuration: one `:default` desk, every setting at the
     # documented default.
     def initialize
@@ -1010,6 +1078,7 @@ module SupportDesk
       @authenticate_method = :authenticate_user!
       @visible_desks_for = nil
       @authorize_console = nil
+      @thread_page = :chats
 
       @desks = { default: DeskConfiguration.new(:default) }
       @assistants = {}
@@ -1029,6 +1098,18 @@ module SupportDesk
       @console_parent_controller = ensure_class_name(value, "console_parent_controller")
     end
 
+    def thread_page=(value)
+      page = value.respond_to?(:to_sym) ? value.to_sym : value
+      unless THREAD_PAGES.include?(page)
+        raise ConfigurationError, "thread_page must be one of #{THREAD_PAGES.map(&:inspect).join(", ")}, got #{value.inspect}"
+      end
+
+      @thread_page = page
+    end
+
+    # Whether a case is read on this engine's own page (`thread_page = :support`).
+    def support_thread_page? = thread_page == :support
+
     # --- The console ------------------------------------------------------------
 
     # Narrow what the console can reach:

data/lib/support_desk/conversation_access.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SupportDesk
+  # chats finds every conversation a request names (the thread, a dock
+  # window, the composer, read, typing, refresh, reactions, edits) by asking,
+  # in order, the relations `Chats::ApplicationController#conversation_lookup_scopes`
+  # returns (chats >= 0.5.1). By default that is the viewer's inbox,
+  # `Messager#chats`, with the host's `config.inbox_scope` applied: the right
+  # rule for a list and the wrong one for a case. A host that keeps support
+  # apart from its inbox (`thread_page = :support`, and an inbox_scope that
+  # leaves SupportDesk::Ticket conversations out) would 404 its requesters
+  # inside their own cases.
+  #
+  # So this adds one relation after chats' own: the viewer's own cases
+  # (SupportDesk::Ticket.conversations_of), through the same participation
+  # and block rules as the inbox, without the host's listing scope. The union
+  # of the scopes is the authorization: nobody gains a conversation they are
+  # not seated in, a non-support conversation the host hides stays hidden, and
+  # a layer of the host's that refuses a conversation (its own
+  # `find_conversation`, or a scope it drops) still refuses it.
+  #
+  # == The contract with the host
+  #
+  # support_desk only ever adds a scope beside the host's. A host that must
+  # refuse a viewer entirely (a suspended account) returns no scopes, and that
+  # is final: with nothing to stand beside, support_desk adds nothing either.
+  # The ticket page asks the same question (SupportDesk::TicketsController
+  # resolves its conversation through chats' own `find_conversation`).
+  #
+  # Prepended to Chats::ApplicationController by the engine, in `to_prepare`
+  # so it survives a code reload.
+  module ConversationAccess
+    protected
+
+    def conversation_lookup_scopes
+      scopes = super
+      return scopes if scopes.empty?
+
+      scopes + [ SupportDesk::Ticket.conversations_of(chats_current_messager) ]
+    end
+  end
+end

data/lib/support_desk/engine.rb

@@ -150,6 +150,13 @@ module SupportDesk
       # needed to load the class.
       _assistant = SupportDesk::Assistant
 
+      # A requester's own case opens through chats whatever the host's
+      # `inbox_scope` lists (SupportDesk::ConversationAccess). Here and not in
+      # an initializer because both classes reload: a reloaded chats
+      # controller is a new class, and it needs the seam again.
+      chats_controller = Chats::ApplicationController
+      chats_controller.prepend(SupportDesk::ConversationAccess) unless chats_controller < SupportDesk::ConversationAccess
+
       SupportDesk.config.validate_classes! if SupportDesk.configured?
     end
   end

data/lib/support_desk/models/ticket.rb

@@ -192,6 +192,35 @@ module SupportDesk
         find_by(conversation_id: conversation.id)
       end
 
+      # The conversations behind +requester+'s own cases, while they still
+      # hold its seat: chats' participation and block rules (`inbox_for`),
+      # without the host's `inbox_scope`. Participation is what makes a
+      # conversation theirs to read; the inbox is only where it is listed.
+      # What chats adds to its lookup (SupportDesk::ConversationAccess) and
+      # what the ticket page reads from.
+      #
+      # A case and its conversation have to point at each other: a direct
+      # conversation whose subject IS one of this requester's cases, that very
+      # case's conversation. A ticket mislinked to a group, or to a
+      # conversation about something else, opens nothing.
+      def conversations_of(requester)
+        return Chats::Conversation.none unless requester.respond_to?(:support_tickets)
+
+        tickets = arel_table
+        conversations = Chats::Conversation.arel_table
+        own_cases = requester.support_tickets.where(tickets[:id].eq(conversations[:subject_id])).select(:conversation_id)
+        Chats::Conversation.inbox_for(requester).direct
+                           .where(subject_type: polymorphic_name)
+                           .where(id: own_cases)
+      end
+
+      # One of them, by id, or nil.
+      def requester_conversation(requester, id)
+        return nil if id.blank?
+
+        conversations_of(requester).find_by(id: id)
+      end
+
       # Open a ticket and post its first message. Usually called as
       # `requester.ask_support!(…)` — or, when the desk writes first, as
       # `agent.open_support_conversation_with!(…)`. This is the seam under
@@ -621,6 +650,7 @@ module SupportDesk
         ticket.send(:record_registration!, posted) if posted
         ticket.send(:stamp_assistant_action!) if by_support && SupportDesk.ai_actor?(by)
         pin_opening_lines!(ticket, notices, posted)
+        post_acknowledgement!(ticket, posted) if posted && !by_support
         ticket
       end
 
@@ -631,6 +661,30 @@ module SupportDesk
         ticket.conversation.post_system_message!(line)
       end
 
+      # The desk's acknowledgement, right under the requester's first message
+      # and in the same transaction, so "did that go through?" is answered by
+      # the very commit that made it so. Pinned one tick AFTER the message
+      # whenever the clock did not move between the two inserts (the same tie
+      # `pin_opening_lines!` breaks the other way), and it is then the
+      # conversation's last message: what a list row previews.
+      #
+      # It is the desk's receipt for words the requester has just written, so
+      # it is never news to them: their read horizon moves through it. Without
+      # that, a tick dated after the clock (a frozen or coarse one) would stay
+      # unread on a page that already shows it, chats' own thread included,
+      # which reads at "now".
+      def post_acknowledgement!(ticket, posted)
+        line = ticket.desk_config.acknowledgement_for(ticket)
+        return if line.blank?
+
+        notice = ticket.conversation.post_system_message!(line)
+        if notice.created_at <= posted.created_at
+          notice.update_columns(created_at: posted.created_at + ordering_tick)
+          ticket.conversation.recompute_last_message!
+        end
+        ticket.conversation.participant_for(ticket.requester)&.read!(at: notice.created_at)
+      end
+
       # chats orders a transcript by (created_at, id), and inserting one row
       # after another does NOT guarantee two different timestamps: frozen
       # time in a test, a coarse column, a clock that doesn't move between
@@ -724,7 +778,7 @@ module SupportDesk
     def chat_locked_notice
       return I18n.t("support_desk.thread.unavailable_notice") if requester_unavailable?
 
-      I18n.t("support_desk.thread.closed_notice")
+      I18n.t("support_desk.thread.closed_notice", **desk_config.line_interpolations(self))
     end
 
     # Whether the person this case belongs to can be written to at all right

data/lib/support_desk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SupportDesk
-  VERSION = "0.3.2"
+  VERSION = "0.4.0"
 end

data/lib/support_desk/wizard.rb

@@ -179,11 +179,7 @@ module SupportDesk
     # The promise shown next to the composer ("we usually reply in under a
     # day"), built from `config.reply_within` — one setting, one truth: the
     # same number the SLA breaches on.
-    def promise
-      return nil if promise_within.nil?
-
-      I18n.t("support_desk.thread.promise", time: self.class.humanize_duration(promise_within))
-    end
+    def promise = target_desk.config.reply_promise
 
     # The promise as a Duration, for hosts that want to phrase it themselves.
     def promise_within = target_desk.config.reply_within

data/lib/support_desk.rb

@@ -402,8 +402,10 @@ module SupportDesk
     #
     # Both surfaces are ordinary PUSHED screens (`context: "default"`), never
     # modals: the wizard is three real URLs and a modal would break the back
-    # gesture between them. The thread itself is deliberately absent — it is
-    # a chats conversation, and it stays under the host's chats rule.
+    # gesture between them. The thread itself is absent under the default
+    # `thread_page = :chats` — it is a chats conversation, and it stays under
+    # the host's chats rule. Under `:support` it is this engine's ticket page,
+    # and a third rule pushes it like the list.
     #
     # +mount+ defaults to wherever the engine is mounted and +title+ to the
     # desk's name.
@@ -429,8 +431,16 @@ module SupportDesk
           properties: { context: "default", title: title, pull_to_refresh_enabled: false },
           comment: "The wizard: every step is a real URL, so it pushes and the back gesture works. " \
                    "Pull to refresh is off — it would throw away what the requester has typed."
-        }
-      ]
+        },
+        (if config.support_thread_page?
+           {
+             patterns: [ "^#{prefix}/tickets/[^/?]+(?:\\?.*)?$" ],
+             properties: { context: "default", title: title, pull_to_refresh_enabled: false },
+             comment: "A case, read on the support page (thread_page = :support). Pull to refresh is off " \
+                      "for the same reason as the wizard: the composer at its foot holds what is typed."
+           }
+         end)
+      ].compact
     end
 
     # A duration in the reader's own language ("1 día", "4 hours") — the
@@ -449,6 +459,24 @@ module SupportDesk
       words.start_with?("Translation missing") ? duration.inspect : words
     end
 
+    # The answer promise, in the unit the desk made it in: `reply_within =
+    # 72.hours` reads "72 hours", `3.days` reads "3 days", `24.hours` reads
+    # "24 hours". A wait is approximate and `humanize_duration` rounds it
+    # ("about 8 hours", "3 days"); a promise is a number somebody chose, and
+    # rounding it says something they did not.
+    #
+    # The words are `support_desk.durations.<unit>`, pluralized by count. A
+    # duration of more than one unit (1.day + 2.hours), a fractional one, or
+    # a unit with no words in this locale is said the way a wait is.
+    def humanize_promise(duration)
+      parts = duration.respond_to?(:parts) ? duration.parts : {}
+      unit, count = parts.first if parts.size == 1
+      key = :"support_desk.durations.#{unit}"
+      return humanize_duration(duration) unless count.is_a?(Integer) && I18n.exists?(key)
+
+      I18n.t(key, count: count)
+    end
+
     # A stable, URL-safe key for an actor (agent, requester, desk), used in
     # cache keys and event payloads. GlobalID params already encode class +
     # id, so two classes can never collide.

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: support_desk
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - rameerez
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-24 00:00:00.000000000 Z
+date: 2026-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -53,22 +54,22 @@ dependencies:
   name: chats
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.2
+        version: 0.5.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.2
+        version: 0.5.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: globalid
   requirement: !ruby/object:Gem::Requirement
@@ -143,6 +144,7 @@ files:
 - app/controllers/support_desk/console/tickets_controller.rb
 - app/controllers/support_desk/tickets_controller.rb
 - app/helpers/support_desk/engine_helper.rb
+- app/helpers/support_desk/thread_helper.rb
 - app/views/chats/slots/_inbox_top.html.erb
 - app/views/chats/slots/_locked_composer.html.erb
 - app/views/support_desk/console/tickets/_actions.html.erb
@@ -171,6 +173,7 @@ files:
 - app/views/support_desk/tickets/index.html.erb
 - app/views/support_desk/tickets/new.html.erb
 - app/views/support_desk/tickets/rate_limited.html.erb
+- app/views/support_desk/tickets/show.html.erb
 - config/console_routes.rb
 - config/locales/support_desk.console.en.yml
 - config/locales/support_desk.console.es.yml
@@ -204,6 +207,7 @@ files:
 - lib/support_desk/console_engine.rb
 - lib/support_desk/console_routes.rb
 - lib/support_desk/context_card.rb
+- lib/support_desk/conversation_access.rb
 - lib/support_desk/current.rb
 - lib/support_desk/doctor.rb
 - lib/support_desk/engine.rb
@@ -244,6 +248,7 @@ metadata:
   bug_tracker_uri: https://github.com/rameerez/support_desk/issues
   documentation_uri: https://github.com/rameerez/support_desk#readme
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -258,7 +263,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.4.10
+signing_key:
 specification_version: 4
 summary: 'Customer support for your Rails app: tickets that are conversations, worked
   by your team and by AI agents with real guardrails'