support_desk 0.5.0 → 0.6.0

data/lib/support_desk/models/ticket/assistance.rb

@@ -374,7 +374,7 @@ module SupportDesk
         end
         ensure_agent!(actor)
 
-        event = write_transition!(:assistant_resumed, actor: actor, request: request) do
+        event = write_transition!(:assistant_resumed, actor: actor, request: request, offers_turn: true) do
           next false unless assistant_paused?
 
           update!(assistant_paused_at: nil, assistant_paused_reason: nil)
@@ -383,7 +383,7 @@ module SupportDesk
         return self unless event
 
         SupportDesk.emit_after_commit(:assistant_resumed, self, by: actor)
-        emit_assistant_turn if awaiting_reply?
+        emit_assistant_turn(record: false) if awaiting_reply?
         self
       end
 
@@ -710,6 +710,8 @@ module SupportDesk
         # would make every draft stale the moment it was written.
         candidate.proposed_turn = assistant_turn
         candidate.save!
+        Event.record!(ticket: self, kind: :draft_proposed, actor: assistant,
+                      payload: { "draft" => candidate.id.to_s, "turn" => candidate.proposed_turn })
         reset_draft_associations!
         stamp_assistant_action!
         broadcast_change
@@ -841,16 +843,43 @@ module SupportDesk
       # It carries the turn, so a job can check `ticket.assistant_turn ==
       # turn` before spending money. A hook that raises is reported: a
       # broken subscriber must not roll back the message that triggered it.
-      def emit_assistant_turn(message = nil)
-        return unless open? && awaiting_reply?
-
-        assistant = self.assistant
+      #
+      # It also writes the turn down — an `assistant_turn` event row, in the
+      # transaction that produced the turn — so a durable reader
+      # (SupportDesk::Events.replay) hears about it even when this process
+      # dies before the in-memory event fires. `record: false` is the
+      # re-emission sweep, which repeats an old turn and owes no new row.
+      def emit_assistant_turn(message = nil, record: true)
+        assistant = assistant_owed_turn
         return if assistant.nil?
-        return unless assistant_policy(assistant).may_observe?
 
+        record_assistant_turn!(assistant, message) if record
         SupportDesk.emit_after_commit(:assistant_turn, self, assistant, message, turn: assistant_turn)
+      end
+
+      # The `assistant_turn` row, on its own: for a transition that hands the
+      # case to her, which writes it under its lock and announces it after.
+      def record_assistant_turn!(assistant = assistant_owed_turn, message = nil) # :nodoc:
+        return if assistant.nil?
+
+        Event.record!(ticket: self, kind: :assistant_turn, actor: :system,
+                      payload: { "turn" => assistant_turn, "assistant" => assistant.key,
+                                 "message" => message&.id&.to_s }.compact)
+      end
+
+      # Whom the case owes a turn right now, or nil. A hook that raises (a
+      # host's `cap`) is reported and owes nothing: a broken subscriber or
+      # policy must not roll back the message that triggered it.
+      def assistant_owed_turn
+        return nil unless open? && awaiting_reply?
+
+        assistant = self.assistant
+        return nil if assistant.nil?
+
+        assistant if assistant_policy(assistant).may_observe?
       rescue StandardError => e
         SupportDesk.report_error(e, context: { hook: :assistant_turn, ticket: id })
+        nil
       end
 
       # A human transition that lowers the effective level below :reply while

data/lib/support_desk/models/ticket.rb

@@ -140,6 +140,12 @@ module SupportDesk
     }
 
     scope :for_desk, ->(key) { where(desk: SupportDesk.desk(key)) }
+    # Cases on +owner+'s desks (nil: the desks with no owner) — and, as
+    # `on_current_desks`, on SupportDesk::Current.owner's. Every screen and
+    # count a requester sees reads through the second: one person can be a
+    # customer of two owners, and neither may show the other's cases.
+    scope :owned_by, ->(owner) { where(desk_id: Desk.owned_by(owner).select(:id)) }
+    scope :on_current_desks, -> { owned_by(SupportDesk::Current.owner) }
     scope :opened_via, ->(channel) { where(opened_via: channel.to_s) }
     scope :opened_between, ->(range) { where(opened_at: range) }
     scope :closed_between, ->(range) { where(closed_at: range) }
@@ -160,10 +166,12 @@ module SupportDesk
       # Measured per DESK, not against whichever desk happens to be the
       # default: two desks can promise different things, and a billing desk
       # that answers in an hour must not be judged by a 24 hour promise.
-      # Pass a key to ask about one desk, nothing to ask about all of them.
+      # Pass a key to ask about one desk, nothing to ask about all of them —
+      # all of SupportDesk::Current.owner's, each judged by its own settings.
       def past_sla(threshold, desk_key: nil, but_not: nil)
         keys = desk_key ? [ desk_key.to_sym ] : SupportDesk.config.desks.keys
-        clauses = keys.filter_map { |key| sla_clause(key, threshold, but_not) }
+        desks = Desk.owned_by(SupportDesk::Current.owner).where(key: keys.map(&:to_s))
+        clauses = desks.filter_map { |desk| sla_clause(desk, threshold, but_not) }
         return none if clauses.empty?
 
         awaiting_reply.not_closed.where.not(waiting_since: nil).where(clauses.reduce(:or))
@@ -192,7 +200,8 @@ module SupportDesk
         find_by(conversation_id: conversation.id)
       end
 
-      # The conversations behind +requester+'s own cases, while they still
+      # The conversations behind +requester+'s own cases on the current
+      # owner's desks (SupportDesk::Current.owner), 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.
@@ -208,7 +217,8 @@ module SupportDesk
 
         tickets = arel_table
         conversations = Chats::Conversation.arel_table
-        own_cases = requester.support_tickets.where(tickets[:id].eq(conversations[:subject_id])).select(:conversation_id)
+        own_cases = requester.support_tickets.on_current_desks
+                             .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)
@@ -279,7 +289,7 @@ module SupportDesk
         # and lose only the message that was supposed to justify them.
         transaction(requires_new: true) do
           next reply_into!(existing, message, files: files, by: opener, by_support: by_support,
-                           request: request, authorize_reuse: authorize_reuse) if existing
+                           request: request, authorize_reuse: authorize_reuse, via: via) if existing
 
           created, inserted = insert_ticket!(
             requester: requester, desk: desk, node: node, about: about, via: via, opened_by: opener,
@@ -298,7 +308,7 @@ module SupportDesk
             # Somebody else's INSERT won by a millisecond. Theirs is the case
             # that exists, so this is a reply into it, policy and all.
             reply_into!(created, message, files: files, by: opener, by_support: by_support,
-                        request: request, authorize_reuse: authorize_reuse)
+                        request: request, authorize_reuse: authorize_reuse, via: via)
           end
         end
       end
@@ -455,13 +465,12 @@ module SupportDesk
       # "on this desk, and waiting longer than its own threshold" — with an
       # upper bound when the caller wants the band between two thresholds
       # (at risk, but not yet breached).
-      def sla_clause(key, threshold, but_not)
-        config = SupportDesk.config.desk(key)
+      def sla_clause(desk, threshold, but_not)
+        config = desk.config
         duration = config.public_send(threshold)
         return nil if duration.nil?
 
-        clause = arel_table[:desk_id].in(Desk.where(key: key.to_s).select(:id).arel)
-                                     .and(arel_table[:waiting_since].lteq(duration.ago))
+        clause = arel_table[:desk_id].eq(desk.id).and(arel_table[:waiting_since].lteq(duration.ago))
         ceiling = but_not && config.public_send(but_not)
         ceiling ? clause.and(arel_table[:waiting_since].gt(ceiling.ago)) : clause
       end
@@ -644,7 +653,7 @@ module SupportDesk
           # error, and this whole transaction goes with it.
           ticket.post_agent_message!(message, files: files, by: by)
         elsif message.present? || files.present?
-          ticket.post_requester_message!(message, files: files)
+          ticket.post_requester_message!(message, files: files, via: ticket.opened_via)
         end
 
         ticket.send(:record_registration!, posted) if posted
@@ -727,7 +736,7 @@ module SupportDesk
       # through here, so an existing case is answered under its row lock,
       # under the desk's reply policy, with the console's authorization hook
       # running before any of it.
-      def reply_into!(ticket, message, files:, by:, by_support:, request:, authorize_reuse:)
+      def reply_into!(ticket, message, files:, by:, by_support:, request:, authorize_reuse:, via:)
         if by_support
           # Only this private outreach path supplies the current turn internally.
           # Public replies must present the token their harness observed.
@@ -740,7 +749,7 @@ module SupportDesk
             # the old API's "hand it back": supported, and it writes nothing.
             next if message.blank? && files.blank?
 
-            posted = ticket.post_requester_message!(message, files: files)
+            posted = ticket.post_requester_message!(message, files: files, via: via)
             ticket.send(:record_registration!, posted)
           end
         end
@@ -914,9 +923,12 @@ module SupportDesk
     # it raises SupportDesk::NotAllowed. Returns the Chats::Message.
     #
     # `by:` the assistant needs `turn:` and her policy's permission — see
-    # SupportDesk::Ticket::Assistance. `metadata:` rides on the message
-    # (provenance for a draft a human sent; hosts nest their own under
-    # "host").
+    # SupportDesk::Ticket::Assistance. A PERSON may pass `turn:` too, and
+    # then the reply is conditional: it is posted only if the case is still
+    # at the turn they read, and raises SupportDesk::StaleTurn otherwise —
+    # the `If-Match` of a reply sent through an API or a review screen.
+    # `metadata:` rides on the message (provenance for a draft a human sent;
+    # hosts nest their own under "host").
     def reply!(body = nil, by: nil, files: [], request: nil, metadata: {}, turn: nil)
       actor = resolve_actor(by)
       ensure_agent!(actor)
@@ -927,6 +939,9 @@ module SupportDesk
 
     # An internal note: in the timeline and the console, never in the
     # conversation, never mirrored to any channel. Returns the Event.
+    #
+    # `turn:` makes it conditional, for a person exactly as for the
+    # assistant: a note about a case that has moved on raises StaleTurn.
     def note!(body, by: nil, request: nil, turn: nil)
       actor = resolve_actor(by)
       ensure_agent!(actor)
@@ -935,6 +950,15 @@ module SupportDesk
 
       assistant = nil
       event = write_transition!(:note, actor: actor, request: request) do
+        if machine || turn
+          # Ticket, then conversation, then fold in what chats committed and
+          # the gem has not registered yet — exactly as a reply does — so a
+          # turn is compared against the case as it really is, not against
+          # one whose next question is a lost callback away. A stale turn
+          # rolls the folding back with everything else.
+          lock_conversation!
+          reconcile_unregistered_messages!
+        end
         if machine
           # Under the lock, from the row: a kill switch that commits while
           # this call waits for the case is a kill switch that stops it (R9).
@@ -942,6 +966,8 @@ module SupportDesk
           ensure_current_turn!(turn)
           policy = assistant_policy(assistant)
           raise AssistantNotAllowed.new(policy, verb: :note) unless policy.may_observe?
+        elsif turn
+          ensure_current_turn!(turn)
         end
         { "note" => body.to_s }
       end
@@ -965,7 +991,7 @@ module SupportDesk
       handing_back = SupportDesk.ai_actor?(to) && !SupportDesk.ai_actor?(actor)
       assignment = nil
 
-      event = write_transition!(:assigned, actor: actor, request: request) do
+      event = write_transition!(:assigned, actor: actor, request: request, offers_turn: handing_back) do
         raise InvalidTransition, "can't assign a closed ticket — reopen it first" if closed?
         # Every mutable question about a seat is asked HERE, under the row
         # lock, from the reloaded row: who holds the case, what her policy
@@ -990,7 +1016,7 @@ module SupportDesk
 
       announce_assignment!(to, first: assignments.count <= 1)
       SupportDesk.emit_after_commit(:ticket_assigned, self, assignment)
-      emit_assistant_turn if handing_back && awaiting_reply?
+      emit_assistant_turn(record: false) if handing_back && awaiting_reply?
       self
     end
 
@@ -1008,7 +1034,7 @@ module SupportDesk
       handing_back = SupportDesk.ai_actor?(to)
       from = nil
       assignment = nil
-      event = write_transition!(:handed_off, actor: actor, request: request) do
+      event = write_transition!(:handed_off, actor: actor, request: request, offers_turn: handing_back) do
         unless assigned_to?(actor)
           raise NotTheAssignee, "#{describe_actor(actor)} doesn't hold ticket #{reference} " \
                                 "(#{assignee ? describe_actor(assignee) : "nobody"} does) — use assign! to override"
@@ -1033,7 +1059,7 @@ module SupportDesk
 
       announce_assignment!(to, first: false)
       SupportDesk.emit_after_commit(:ticket_handed_off, self, assignment, from: from, note: note)
-      emit_assistant_turn if handing_back && awaiting_reply?
+      emit_assistant_turn(record: false) if handing_back && awaiting_reply?
       self
     end
 
@@ -1352,9 +1378,27 @@ module SupportDesk
     # --- Internals -----------------------------------------------------------------
 
     # Post a message as the requester — what `ask_support!` says first, and
-    # what an inbound channel replays.
-    def post_requester_message!(body, files: []) # :nodoc:
-      requester.message!(conversation, body, files: files)
+    # what an inbound channel, an importer or a connector replays:
+    #
+    #   ticket.post_requester_message!("Sigue sin llegar", via: :email, external_id: "<CAF…@mail.gmail.com>")
+    #
+    # `via:` and `external_id:` are provenance. They ride on the message as
+    # `metadata["support_desk"]`, so a transcript can say which channel each
+    # line came in through, and an importer can tell the message it already
+    # brought over from the one it has not. `:in_app` is where every message
+    # comes from unless somebody says otherwise, so it is never stamped.
+    #
+    # Folded into the clocks like any other requester message — by the chats
+    # subscriber, after commit. Returns the Chats::Message.
+    def post_requester_message!(body, files: [], via: nil, external_id: nil)
+      provenance = { "via" => (via.to_s unless via.nil? || via.to_sym == :in_app),
+                     "external_id" => external_id&.to_s }.compact
+      return requester.message!(conversation, body, files: files) if provenance.empty?
+
+      # chats' `message!` takes no metadata; the validations are the same.
+      attributes = { sender: requester, body: body, metadata: { "support_desk" => provenance } }
+      attributes[:files] = files if files.present?
+      conversation.messages.create!(**attributes)
     end
 
     # Post a message as the DESK, signed by the agent who wrote it — every
@@ -1498,6 +1542,10 @@ module SupportDesk
         # must not later turn an already-answered question back into work.
         lock_conversation!
         reconcile_unregistered_messages!
+        # Optional for a person, and checked only once the case is folded in:
+        # a customer message that landed after they read the case is exactly
+        # what makes their answer stale.
+        ensure_current_turn!(turn) if turn
         ensure_writable!
         apply_reply_policy!(by, request: request)
         posted = post_agent_message!(body, files: files, by: by, metadata: metadata)
@@ -1580,9 +1628,16 @@ module SupportDesk
     # Run a transition under the row lock: yield, write exactly one event
     # row, and (once everything has committed) broadcast and emit. The block
     # returns the event payload, or false when there is nothing to do.
-    def write_transition!(kind, actor:, request: nil, &block)
+    #
+    # `offers_turn:` is for the transitions that hand the case (back) to the
+    # assistant: the `assistant_turn` row they owe is written under the same
+    # lock, so it commits with them or not at all.
+    def write_transition!(kind, actor:, request: nil, offers_turn: false, &block)
       event = nil
-      with_lock { event = record_transition!(kind, actor: actor, &block) }
+      with_lock do
+        event = record_transition!(kind, actor: actor, &block)
+        record_assistant_turn! if event && offers_turn
+      end
       publish_transition(event, kind, actor, request) if event
       event
     end

data/lib/support_desk/queue.rb

@@ -200,8 +200,10 @@ module SupportDesk
       @agent_key ||= [ agent.class.polymorphic_name, agent.id.to_s ]
     end
 
+    # The desk's ROW, not only its key: every owner has a `:default` desk,
+    # and one agent working two owners' queues has two badges.
     def badge_cache_key
-      [ "support_desk", "queue", desk.key, "badge", SupportDesk.actor_key(agent) ]
+      [ "support_desk", "queue", desk.key, desk.id, "badge", SupportDesk.actor_key(agent) ]
     end
   end
 end

data/lib/support_desk/replay.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module SupportDesk
+  # Everything the desk wrote down, in an order a reader can checkpoint
+  # without ever skipping a row. Reached through SupportDesk::Events.replay;
+  # see there for the contract and the README for why it is shaped this way.
+  #
+  # Two tables are the durable record: `support_desk_events` (every
+  # transition, plus the `assistant_turn` and `draft_proposed` signals) and
+  # `support_desk_message_registrations` (every message folded into a case).
+  # Both carry `xact_id`, the 64-bit id of the transaction that wrote the row
+  # (`pg_current_xact_id()`), and `position`, drawn from ONE sequence, so
+  # `(xact_id, position)` is a single order across both and `position` alone
+  # identifies a row.
+  class Replay # :nodoc:
+    # The cursor a reader keeps between pages of one range, as JSON-friendly
+    # strings: the range's fixed end, and the last row handled.
+    RESUME_KEYS = %w[until xact_id position].freeze
+
+    def initialize(horizon:, resume: nil, batch_size: 500)
+      @horizon = Integer(horizon || 0)
+      @resume = resume&.to_h&.transform_keys(&:to_s)
+      @batch_size = Integer(batch_size)
+      raise ArgumentError, "batch_size must be positive" unless @batch_size.positive?
+    end
+
+    # Yield every row of the range, oldest first, then return the range's
+    # end — the next horizon. Nothing is returned for a range that did not
+    # drain: a raise leaves the caller's checkpoint where it was.
+    #
+    # Uncached, always: the snapshot is the same SQL on every poll, and a
+    # query cache — on in every request and job — would hand back the first
+    # answer and pin the horizon for as long as the executor lives.
+    def each_row(&block)
+      ensure_supported!
+      Event.uncached { read_range(&block) }
+    end
+
+    private
+
+    def read_range
+      upper, after = start
+
+      loop do
+        page = next_page(upper, after)
+        break if page.empty?
+
+        page.each do |row|
+          after = [ row.xact_id, row.position ]
+          yield row, { "until" => upper, "xact_id" => after[0], "position" => after[1] }
+        end
+      end
+
+      upper
+    end
+
+    attr_reader :horizon, :resume, :batch_size
+
+    # A resumed range keeps the end it was started with. Recomputing it
+    # would move the goalposts mid-range — harmless for completeness, but
+    # the sub-cursor would then describe a range nobody checkpointed.
+    def start
+      return [ snapshot_horizon, nil ] if resume.nil?
+
+      missing = RESUME_KEYS - resume.keys
+      raise ArgumentError, "resume: is missing #{missing.join(", ")} — pass back what replay yielded" if missing.any?
+
+      [ Integer(resume["until"]), [ Integer(resume["xact_id"]), Integer(resume["position"]) ] ]
+    end
+
+    # The oldest transaction still running. Every transaction below it has
+    # committed or aborted, so the rows below it are final: present now, or
+    # never going to exist.
+    def snapshot_horizon
+      Event.connection.select_value("SELECT pg_snapshot_xmin(pg_current_snapshot())::text::bigint").to_i
+    end
+
+    # The next page across both tables. Each table gives its own first
+    # `batch_size` rows past the cursor, and the merged first `batch_size`
+    # are exactly the first rows of the merged order.
+    def next_page(upper, after)
+      sources.flat_map { |model| page_of(model, upper, after) }
+             .sort_by { |row| [ row.xact_id, row.position ] }
+             .first(batch_size)
+    end
+
+    def page_of(model, upper, after)
+      table = model.quoted_table_name
+      scope = model.where("#{table}.xact_id >= ? AND #{table}.xact_id < ?", horizon, upper)
+      scope = scope.where("(#{table}.xact_id, #{table}.position) > (?, ?)", *after) if after
+      scope.order(:xact_id, :position).limit(batch_size).to_a
+    end
+
+    def sources = [ Event, MessageRegistration ]
+
+    def ensure_supported!
+      unless Event.connection.adapter_name.match?(/\Apostg/i)
+        raise ConfigurationError,
+              "SupportDesk::Events.replay needs PostgreSQL 13 or later: it reads transaction ids " \
+              "(pg_current_xact_id), which #{Event.connection.adapter_name} does not have."
+      end
+      return if sources.all? { |model| model.column_names.include?("xact_id") }
+
+      raise ConfigurationError,
+            "support_desk's replay columns are missing — run `rails g support_desk:upgrade` and " \
+            "`rails db:migrate` (support_desk 0.6.0 adds position and xact_id)."
+    end
+  end
+end

data/lib/support_desk/timeline.rb

@@ -118,7 +118,7 @@ module SupportDesk
     end
 
     def event_entries
-      ticket.events.chronological.map { |event| Entry.new(at: event.created_at, event: event) }
+      ticket.events.history.chronological.map { |event| Entry.new(at: event.created_at, event: event) }
     end
 
     # Proposals somebody decided about — sent, discarded, or overtaken.

data/lib/support_desk/version.rb

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

data/lib/support_desk.rb

@@ -95,6 +95,7 @@ module SupportDesk
       @subscribers = nil
       @desks = nil
       @assistants = nil
+      Current.resolved = nil
       self
     end
 
@@ -102,18 +103,20 @@ module SupportDesk
     # tests that truncate tables between examples.
     def reset_desks!
       @desks = nil
+      Current.resolved = nil
       self
     end
 
     # --- Assistants -----------------------------------------------------------
 
-    # The assistant record for +key+, memoised per process — or the desk's
-    # default when called with nothing. nil when this installation has no
-    # assistant at all, which is the answer every existing host gets.
+    # The assistant record for +key+ — or the desk's default when called
+    # with nothing — for +owner+ (SupportDesk::Current.owner unless you
+    # say). nil when this installation has no assistant at all, which is
+    # the answer every existing host gets.
     #
-    # Found or created exactly like a desk, and never INSERT-first: an
-    # assistant is read on every transition and written once in her life.
-    def assistant(key = nil)
+    # Found or created exactly like a desk, never INSERT-first, and cached
+    # the same way: per process without an owner, per request with one.
+    def assistant(key = nil, owner: Current.owner)
       key = (key || config.default_assistant_key)
       return nil if key.nil?
 
@@ -128,7 +131,7 @@ module SupportDesk
       # message she signed still says the same thing after somebody takes
       # her out of the initializer (R8). It writes only when configuration
       # and the row disagree.
-      (assistants[key] ||= Assistant.for(key)).snapshot_disclosure!
+      resolve(assistants, :assistant, key, owner) { Assistant.for(key, owner: owner) }.snapshot_disclosure!
     end
 
     # Every assistant record this process has resolved, keyed by key.
@@ -186,9 +189,10 @@ module SupportDesk
       # A seat nobody can sit in any more is not a silence problem, and it
       # must not need a `responds_within` to be noticed (R6).
       moved = reclaim_assistant_seats!
-      config.assistants.each_key do |key|
-        agent = assistant(key)
-        window = agent&.responds_within
+      # Every owner's assistants, not only the ones this process resolved:
+      # the sweep runs once for the whole installation.
+      Assistant.where(key: config.assistants.keys.map(&:to_s)).find_each do |agent|
+        window = agent.responds_within
         next if window.nil?
 
         Ticket.open.assigned_to(agent).awaiting_reply.waiting_over(window).find_each do |ticket|
@@ -214,8 +218,9 @@ module SupportDesk
       older_than = older_than.to_i.seconds unless older_than.respond_to?(:ago)
       emitted = 0
 
-      config.desks.each_key do |key|
-        agent = desk(key)&.assistant
+      # Every owner's desks, for the same reason as the sweep above.
+      Desk.where(key: config.desks.keys.map(&:to_s)).find_each do |desk|
+        agent = desk.assistant
         # Repair before deciding. A requester message whose registration was
         # lost after commit leaves the clocks describing a case that no longer
         # exists — and `assistant_idle_since` reads those clocks, so the case
@@ -223,7 +228,7 @@ module SupportDesk
         # in COMMITS on its own and emits the turn it produces, so a dead
         # process followed by nothing but this task still ends in an
         # actionable turn (R3).
-        Ticket.for_desk(key).with_unregistered_requester_messages.find_each do |ticket|
+        desk.tickets.with_unregistered_requester_messages.find_each do |ticket|
           emitted += 1 if ticket.reconcile_and_commit!.positive?
         rescue StandardError => e
           report_error(e, context: { hook: :redispatch_assistant_turns, ticket: ticket.id })
@@ -231,10 +236,10 @@ module SupportDesk
 
         next if agent.nil?
 
-        Ticket.open.for_desk(key).assistant_idle_since(older_than.ago).find_each do |ticket|
+        desk.tickets.open.assistant_idle_since(older_than.ago).find_each do |ticket|
           next unless ticket.assistant_policy(agent).may_observe?
 
-          ticket.send(:emit_assistant_turn)
+          ticket.send(:emit_assistant_turn, record: false)
           emitted += 1
         end
       end
@@ -243,34 +248,46 @@ module SupportDesk
 
     # --- Desks ------------------------------------------------------------------
 
-    # The desk record for +key+, memoised per process.
+    # The desk record for +key+, for +owner+ (SupportDesk::Current.owner
+    # unless you say). Keys are declared in code; owners multiply ROWS, so
+    # every owner has its own `:default` desk and `:billing` means the same
+    # thing for all of them.
     #
     # Lazily created with `find_by || create_or_find_by!` and NEVER
     # INSERT-first: a desk is read thousands of times and written once, and
     # an INSERT that fails its unique index on every page view is noise in
     # the log and a wasted round trip.
-    def desk(key = :default)
+    #
+    # Cached in two places, on purpose. A desk with no owner is memoised for
+    # the life of the process, as it always was: there is one of each, and
+    # its settings change with a deploy. An owned desk is cached for the
+    # request or job (in SupportDesk::Current), because owners are many,
+    # come and go, and change their settings at runtime — a process-wide
+    # memo would grow with every customer and serve yesterday's name.
+    def desk(key = :default, owner: Current.owner)
       key = (key || :default).to_sym
       return nil unless config.desk?(key) || key == :default
 
-      desks[key] ||= Desk.for(key)
+      resolve(desks, :desk, key, owner) { Desk.for(key, owner: owner) }
     end
 
-    # Every desk record this process has resolved, keyed by key.
+    # Every ownerless desk record this process has resolved, keyed by key.
     def desks # :nodoc:
       @desks ||= {}
     end
 
     # --- Topics -----------------------------------------------------------------
 
-    # The Topic at +path+, looked up across every configured desk's tree, or
-    # a Topic::Unknown that still renders (never raises in a view).
+    # The Topic at +path+, looked up across every configured desk's tree —
+    # the current owner's own trees first, when `config.desk_settings` hands
+    # them one — or a Topic::Unknown that still renders (never raises in a
+    # view).
     def find_topic(path)
       return nil if path.nil?
 
       path = path.to_s
-      config.desks.each_value do |desk|
-        node = desk.topics.find(path)
+      topic_trees.each do |tree|
+        node = tree.find(path)
         return node if node
       end
 
@@ -496,6 +513,24 @@ module SupportDesk
 
     private
 
+    # The memo behind `desk` and `assistant`: the process-wide +memo+ for
+    # ownerless rows, the request's SupportDesk::Current for owned ones.
+    def resolve(memo, kind, key, owner)
+      return memo[key] ||= yield if owner.nil?
+      unless owner.respond_to?(:persisted?) && owner.persisted?
+        raise ArgumentError, "a support desk owner must be a saved record, got #{owner.inspect}"
+      end
+
+      Current.resolved_records[[ kind, owner.class.polymorphic_name, owner.id, key ]] ||= yield
+    end
+
+    def topic_trees
+      trees = config.desks.values.map(&:topics)
+      return trees if config.desk_settings.nil?
+
+      Desk.owned_by(Current.owner).where(key: config.desks.keys.map(&:to_s)).map { |desk| desk.config.topics } + trees
+    end
+
     def register(registry, klass)
       registry << klass.name if klass.name
       klass