support_desk 0.5.0 → 0.6.0

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

@@ -241,6 +241,18 @@ SupportDesk.configure do |config|
   #   desk.agents { User.where(finance: true) }
   # end
 
+  # ==========================================================================
+  # A DESK PER CUSTOMER
+  # ==========================================================================
+  #
+  # Set the owner per request (`SupportDesk::Current.owner = current_account`
+  # in a before_action) and per job, and every owner gets its own desks.
+  # Their settings can come from their own rows — a Hash of desk or
+  # assistant settings, overlaid on everything above:
+  #
+  # config.desk_settings      = ->(desk)      { desk.owner&.support_settings }
+  # config.assistant_settings = ->(assistant) { assistant.owner&.assistant_settings }
+
   # ==========================================================================
   # EVENTS — the gem emits, your app delivers
   # ==========================================================================

data/lib/generators/support_desk/upgrade_generator.rb

@@ -16,7 +16,7 @@ module SupportDesk
       include ActiveRecord::Generators::Migration
 
       source_root File.expand_path("templates", __dir__)
-      desc "Add the migrations a support_desk version bump needs (opened_by, assistants, message registration receipts)"
+      desc "Add the migrations a support_desk version bump needs (opened_by, assistants, message registration receipts, owners, replay)"
 
       # Rails' migration numbering, borrowed from ActiveRecord's generators.
       def self.next_migration_number(dir)
@@ -38,6 +38,18 @@ module SupportDesk
                            File.join(db_migrate_path, "create_support_desk_message_registrations.rb")
       end
 
+      # 0.6: owners on desks and assistants, and the replay columns. The same
+      # files on a fresh install and an upgrade.
+      def create_owners_migration
+        migration_template "add_owners_to_support_desk.rb.erb",
+                           File.join(db_migrate_path, "add_owners_to_support_desk.rb")
+      end
+
+      def create_replay_migration
+        migration_template "add_replay_to_support_desk.rb.erb",
+                           File.join(db_migrate_path, "add_replay_to_support_desk.rb")
+      end
+
 
       def display_post_upgrade_message
         say "\n🎫 support_desk upgrade migrations copied.", :green
@@ -61,7 +73,15 @@ module SupportDesk
         say "     old web/jobs, migrate, then start only the new version. Review historical"
         say "     suspect callbacks before resuming; old clocks cannot prove delivery."
         say "     Do not roll code back to a writer that cannot record receipts."
-        say "  6. See the CHANGELOG for the full list.\n", :green
+        say "  6. 0.6.0: desks and assistants gain an optional owner (one desk per"
+        say "     customer: SupportDesk::Current.owner = current_account). Turn it on in"
+        say "     THREE STAGES: migrate; deploy 0.6 to every process and retire every 0.5"
+        say "     one; only then set SupportDesk::Current.owner. A 0.5 process finds desks"
+        say "     by key alone and, once owned rows exist, can pick another owner's."
+        say "     On PostgreSQL 13+, events and message registrations gain xact_id and"
+        say "     position for SupportDesk::Events.replay. That migration rewrites the"
+        say "     events table: run it in a quiet window."
+        say "  7. See the CHANGELOG for the full list.\n", :green
       end
 
       private

data/lib/support_desk/brief.rb

@@ -179,7 +179,7 @@ module SupportDesk
       {
         name: Chats.display_name_for(requester),
         since: requester.try(:created_at),
-        open_cases: Ticket.not_closed.where(requester: requester).count,
+        open_cases: Ticket.owned_by(ticket.desk&.owner).not_closed.where(requester: requester).count,
         context: requester.try(:support_context) || {}
       }
     end

data/lib/support_desk/configuration.rb

@@ -81,6 +81,9 @@ module SupportDesk
         assistant: nil
       }.freeze
 
+      # Everything `apply` may set: the defaults, plus the agent pool.
+      SETTABLE = (DEFAULTS.keys + %i[agents]).freeze
+
       attr_reader :key, :fallback
 
       # A desk's settings, falling back to +fallback+ for anything it
@@ -522,6 +525,25 @@ module SupportDesk
       # Whether THIS desk states the setting itself, rather than inheriting.
       def own?(name) = @settings.key?(name) # :nodoc:
 
+      # Set every setting in +settings+ through its own setter, so a value
+      # from a row is validated exactly like one from the initializer.
+      # `topics:` takes the same block `config.topics` does. What
+      # `config.desk_settings` returns comes in through here.
+      def apply(settings) # :nodoc:
+        settings.to_h.each do |name, value|
+          name = name.to_sym
+          if name == :topics
+            topics(&value)
+          elsif SETTABLE.include?(name)
+            public_send(:"#{name}=", value)
+          else
+            raise ConfigurationError,
+                  "desk #{key}: #{name.inspect} is not a desk setting (#{SETTABLE.map(&:inspect).join(", ")}, :topics)"
+          end
+        end
+        self
+      end
+
       # Forget a setting so this desk inherits it again (tests).
       def reset_setting(name) # :nodoc:
         @settings.delete(name)
@@ -662,12 +684,18 @@ module SupportDesk
         disclosure_line: :"support_desk.system.assistant_disclosure"
       }.freeze
 
-      attr_reader :key
+      # Everything `apply` may set.
+      SETTABLE = (DEFAULTS.keys + %i[hand_off_when cap]).freeze
+
+      attr_reader :key, :fallback
 
       # A fresh assistant, everything at its documented default — except
-      # `disclosure`, which has none.
-      def initialize(key)
+      # `disclosure`, which has none. With a +fallback+ (the initializer's
+      # own assistant, for one whose settings come from a row), anything it
+      # doesn't state is read from there instead.
+      def initialize(key, fallback: nil)
         @key = key.to_sym
+        @fallback = fallback
         @settings = {}
         @hand_off_when = nil
         @cap = nil
@@ -845,7 +873,7 @@ module SupportDesk
       def hand_off_when(&block)
         return @hand_off_when = block if block
 
-        @hand_off_when
+        @hand_off_when || fallback&.hand_off_when
       end
 
       # Set it, validating on assignment (see the reader above).
@@ -859,7 +887,7 @@ module SupportDesk
       def cap(&block)
         return @cap = block if block
 
-        @cap
+        @cap || fallback&.cap
       end
 
       # Set it, validating on assignment (see the reader above).
@@ -926,6 +954,7 @@ module SupportDesk
 
       def read(name) # :nodoc:
         return @settings[name] if @settings.key?(name)
+        return fallback.read(name) if fallback
 
         DEFAULTS[name]
       end
@@ -933,6 +962,22 @@ module SupportDesk
       # Whether this assistant states the setting herself (tests).
       def own?(name) = @settings.key?(name) # :nodoc:
 
+      # Set every setting in +settings+ through its own setter — what
+      # `config.assistant_settings` returns comes in through here.
+      def apply(settings) # :nodoc:
+        settings.to_h.each do |name, value|
+          name = name.to_sym
+          unless SETTABLE.include?(name)
+            raise ConfigurationError,
+                  "assistant #{key}: #{name.inspect} is not an assistant setting " \
+                  "(#{SETTABLE.map(&:inspect).join(", ")})"
+          end
+
+          public_send(:"#{name}=", value)
+        end
+        self
+      end
+
       # Forget a setting so it goes back to its default (tests).
       def reset_setting(name) # :nodoc:
         @settings.delete(name)
@@ -1081,6 +1126,8 @@ module SupportDesk
       @thread_page = :chats
 
       @desks = { default: DeskConfiguration.new(:default) }
+      @desk_settings = nil
+      @assistant_settings = nil
       @assistants = {}
       @default_assistant = nil
       @warnings = []
@@ -1127,7 +1174,7 @@ module SupportDesk
     # back records, a relation, or plain desk keys — all three read the same
     # way in an initializer, so all three are accepted here.
     def desks_visible_to(agent)
-      return Desk.all if visible_desks_for.nil?
+      return Desk.owned_by(Current.owner) if visible_desks_for.nil?
 
       Array(visible_desks_for.call(agent)).filter_map do |desk|
         desk.is_a?(Desk) ? desk : SupportDesk.desk(desk)
@@ -1160,6 +1207,50 @@ module SupportDesk
       false
     end
 
+    # --- Settings that live in rows ------------------------------------------------
+
+    # Where a desk's settings come from when they are not all in code — one
+    # desk per customer, product or workspace, each with its own name and
+    # promise:
+    #
+    #   config.desk_settings = ->(desk) { desk.owner&.support_settings }
+    #
+    # Called with the Desk record; returns a Hash of desk settings (`name:`,
+    # `reply_within:`, `topics:` with a block…) or nil. Each value goes
+    # through its setter, so a bad row fails like a bad initializer, and
+    # anything the Hash leaves out is read from the initializer as before.
+    # Read once per record: an owned desk is resolved once per request or
+    # job, so a change is picked up by the next one.
+    attr_reader :desk_settings
+
+    def desk_settings=(value)
+      @desk_settings = value.nil? ? nil : ensure_callable(value, "desk_settings")
+    end
+
+    # The same, for an assistant: `autonomy:`, `disclosure:`, `max_turns:`…
+    #
+    #   config.assistant_settings = ->(assistant) { assistant.owner&.assistant_settings }
+    attr_reader :assistant_settings
+
+    def assistant_settings=(value)
+      @assistant_settings = value.nil? ? nil : ensure_callable(value, "assistant_settings")
+    end
+
+    # The configuration a Desk record works under: the initializer's desk,
+    # overlaid with what `desk_settings` says about this one. Internal —
+    # read it as `desk.config`.
+    def desk_configuration_for(record) # :nodoc:
+      base = desk(record.key)
+      overlay(base, desk_settings&.call(record)) { DeskConfiguration.new(base.key, fallback: base) }
+    end
+
+    # The same, for an Assistant record. Raises ConfigurationError when the
+    # initializer no longer declares her — rows add to code, never replace it.
+    def assistant_configuration_for(record) # :nodoc:
+      base = assistant(record.key)
+      overlay(base, assistant_settings&.call(record)) { AssistantConfiguration.new(base.key, fallback: base) }
+    end
+
     # --- Desks ------------------------------------------------------------------
 
     # Read or configure a desk:
@@ -1422,6 +1513,15 @@ module SupportDesk
             "Add `supportable topic: :#{topic.path}` to #{name}."
     end
 
+    def overlay(base, settings)
+      return base if settings.blank?
+      unless settings.respond_to?(:to_h)
+        raise ConfigurationError, "#{base.key}: settings hooks must return a Hash or nil, got #{settings.inspect}"
+      end
+
+      yield.apply(settings)
+    end
+
     def ensure_class_name(value, name)
       string = value.is_a?(Class) ? value.name : value.to_s
       raise ConfigurationError, "#{name} can't be blank" if string.strip.empty?

data/lib/support_desk/context_card.rb

@@ -95,7 +95,7 @@ module SupportDesk
 
     # How many open cases this requester has right now, this one included.
     def requester_open_tickets
-      Ticket.not_closed.where(requester: requester).count
+      Ticket.owned_by(ticket.desk&.owner).not_closed.where(requester: requester).count
     end
 
     # The same card as a Hash, for a JSON console.

data/lib/support_desk/current.rb

@@ -22,5 +22,27 @@ module SupportDesk
     # The current ActionDispatch::Request, when there is one. Only ever used
     # to enrich event payloads (IP, user agent) — never to authorize.
     attribute :request
+
+    # Whose desks these are: the account, workspace or product this request
+    # or job serves, in an app that runs one support desk per customer.
+    # `SupportDesk.desk(:default)` is then THIS owner's default desk, and
+    # `Ticket.for_desk`, the SLA scopes and the console's desk list read
+    # this owner's rows only. nil — the default — is the single-desk app
+    # every install was before 0.6, and it reads the rows with no owner.
+    #
+    #   before_action { SupportDesk::Current.owner = current_workspace }
+    #   SupportDesk::Current.set(owner: workspace) { … }       # in a job
+    #
+    # Anything reached FROM a ticket ignores it: a case knows its desk, and
+    # a desk knows its owner.
+    attribute :owner
+
+    # The owned desks and assistants this request or job has resolved —
+    # SupportDesk.desk's cache for owned rows. Gone with the request.
+    attribute :resolved
+
+    def self.resolved_records # :nodoc:
+      self.resolved ||= {}
+    end
   end
 end

data/lib/support_desk/events.rb

@@ -19,7 +19,48 @@ module SupportDesk
   # 3. **Mirrored.** Every event is also published on ActiveSupport
   #    ::Notifications as `"<event>.support_desk"` for APM and hosts that
   #    prefer that bus.
+  #
+  # In-memory events are lost with the process that was going to fire them.
+  # What is NOT lost is what the transitions wrote down, and
+  # `SupportDesk::Events.replay` reads that back — see below.
   module Events
+    # Read the desk's durable record — every event row (transitions, plus the
+    # `assistant_turn` and `draft_proposed` signals) and every message
+    # registration — from +horizon+, oldest first. PostgreSQL 13+.
+    #
+    #   horizon = SupportDesk::Events.replay(horizon: checkpoint.horizon) do |row|
+    #     Bridge.ingest(row)          # idempotent: row.position is unique across both tables
+    #   end
+    #   checkpoint.update!(horizon: horizon)
+    #
+    # The horizon is a TRANSACTION id, never a row position: positions are
+    # handed out at insert and transactions commit in any order, so a reader
+    # that checkpoints "the last position I saw" skips the row a slower
+    # transaction committed behind it. Each call captures the oldest
+    # transaction still running (`pg_snapshot_xmin(pg_current_snapshot())`),
+    # yields every row with `horizon <= xact_id < that`, in `(xact_id,
+    # position)` order and in pages of +batch_size+, and only then returns
+    # it as the next horizon. A raise returns nothing, and the range is read
+    # again next time — so readers deduplicate.
+    #
+    # A long range can be resumed. The block's second argument is a cursor
+    # into the range; save it once a row's effects are durable, and pass it
+    # back as `resume:` to continue where that left off, the range's end
+    # unchanged:
+    #
+    #   SupportDesk::Events.replay(horizon: c.horizon, resume: c.resume) do |row, resume|
+    #     Bridge.ingest(row)
+    #     c.update!(resume: resume)
+    #   end
+    #
+    # Call it outside a transaction: a reader holding a transaction id holds
+    # the horizon back with it.
+    def self.replay(horizon:, resume: nil, batch_size: 500, &block)
+      raise ArgumentError, "SupportDesk::Events.replay needs a block" unless block
+
+      Replay.new(horizon: horizon, resume: resume, batch_size: batch_size).each_row(&block)
+    end
+
     # The catalogue. Keys are event names; values document the arguments
     # subscribers receive (see 09-events-and-notifications).
     CATALOGUE = {

data/lib/support_desk/launcher.rb

@@ -39,7 +39,14 @@ module SupportDesk
         return unless conversation&.subject_type == SupportDesk::Ticket.polymorphic_name
         return unless messager.respond_to?(:unread_support_count)
 
-        broadcast_badge_of(messager)
+        broadcast_badge_of(messager, owner: conversation.subject&.desk&.owner)
+      end
+
+      # The stream a requester's badge listens on: one per owner, because a
+      # person who is a customer of two owners has two launchers, and each
+      # counts only its own owner's cases.
+      def stream(requester, owner = SupportDesk::Current.owner)
+        [ requester, :support_desk, owner ].compact
       end
 
       # Replace +requester+'s launcher badge, wherever it is on screen: one
@@ -51,12 +58,15 @@ module SupportDesk
       # telling, from a job, whether anybody is listening, and a switch for it
       # would let a launcher's badge silently never move. Support is
       # human-paced, so this is one small job per message in a case.
-      def broadcast_badge_of(requester)
+      #
+      # The job knows nothing of the request that wrote the message, so the
+      # owner travels with it and the badge counts under it.
+      def broadcast_badge_of(requester, owner: nil)
         Turbo::StreamsChannel.broadcast_replace_later_to(
-          requester, :support_desk,
+          *stream(requester, owner),
           target: BADGE_ID,
           partial: BADGE_PARTIAL,
-          locals: { requester: requester }
+          locals: { requester: requester, owner: owner }.compact
         )
       end
     end

data/lib/support_desk/models/assistant.rb

@@ -24,6 +24,14 @@ module SupportDesk
 
     acts_as_support_agent kind: :ai, if: :active?
 
+    # Whose assistant she is, in an app with a desk per customer — the same
+    # owner as the desks she works. nil for the single-desk app.
+    belongs_to :owner, polymorphic: true, optional: true
+
+    # nil, rather than a MissingAttributeError, until the 0.6 migration has
+    # added the column: an unmigrated install has no owners.
+    def owner = has_attribute?(:owner_id) ? super : nil
+
     # Ruby-side default so settings is always a Hash even on MySQL, where a
     # JSON column can't carry a DB default.
     attribute :settings, default: -> { {} }
@@ -34,18 +42,36 @@ module SupportDesk
 
     # The assistant for +key+, found or created. Never INSERT-first, exactly
     # like Desk.for: read on every transition, written once.
-    def self.for(key)
+    def self.for(key, owner: nil)
       key = key.to_s
-      find_by(key: key) || create_or_find_by!(key: key)
+      scope = owned_by(owner)
+      scope.find_by(key: key) || scope.create_or_find_by!(key: key)
+    end
+
+    # Hers, for +owner+ — see Desk.owned_by.
+    def self.owned_by(owner)
+      return all if owner.nil? && !column_names.include?("owner_id")
+
+      where(owner: owner)
     end
 
     # --- Configuration ----------------------------------------------------------
 
-    # Her slice of the configuration. Raises ConfigurationError when nothing
-    # declares her any more — which is why everything below reads through
-    # #settings_config and falls back to the safest answer instead.
+    # Her slice of the configuration: the initializer's, overlaid with what
+    # `config.assistant_settings` says about this row. Raises
+    # ConfigurationError when nothing declares her any more — which is why
+    # everything below reads through #settings_config and falls back to the
+    # safest answer instead.
     def config
-      SupportDesk.config.assistant(key)
+      return SupportDesk.config.assistant(key) if SupportDesk.config.assistant_settings.nil?
+
+      @config ||= SupportDesk.config.assistant_configuration_for(self)
+    end
+
+    # A reloaded assistant reads her settings again.
+    def reload(*)
+      @config = nil
+      super
     end
 
     # Whether this row still has configuration behind it. False for an
@@ -158,10 +184,11 @@ module SupportDesk
 
     # --- Where she works --------------------------------------------------------
 
-    # The desks whose configuration points at her.
+    # The desks whose configuration points at her — her owner's.
     def desks
       SupportDesk.config.desks.each_key.filter_map do |desk_key|
-        SupportDesk.desk(desk_key) if SupportDesk.config.desk(desk_key).assistant_key == key.to_sym
+        desk = SupportDesk.desk(desk_key, owner: owner)
+        desk if desk.config.assistant_key == key.to_sym
       end
     end
 
@@ -172,7 +199,8 @@ module SupportDesk
 
     # The assistant, in one line.
     def inspect
-      "#<SupportDesk::Assistant #{key} #{name.inspect} #{autonomy} #{active? ? "active" : "inactive"}>"
+      "#<SupportDesk::Assistant #{key} #{name.inspect} #{autonomy} #{active? ? "active" : "inactive"}" \
+        "#{" #{owner_type}##{owner_id}" if try(:owner_id)}>"
     end
 
     private

data/lib/support_desk/models/concerns/requester.rb

@@ -87,9 +87,10 @@ module SupportDesk
     # what they don't.
     def support_context = {}
 
-    # True when any of this requester's open tickets is waiting on the desk.
+    # True when any of this requester's open tickets is waiting on the desk
+    # — on the current owner's desks, like everything a requester sees.
     def awaiting_support_reply?
-      support_tickets.not_closed.awaiting_reply.exists?
+      support_tickets.on_current_desks.not_closed.awaiting_reply.exists?
     end
 
     # Unread messages across every support conversation this requester has,

data/lib/support_desk/models/desk.rb

@@ -19,9 +19,20 @@ module SupportDesk
   #
   # Rows are created lazily and never INSERT-first: a desk is read on every
   # page and written once in its life.
+  #
+  # An app that runs a desk per customer gives each one an OWNER (any
+  # record: an account, a workspace, a product). The key stays the same —
+  # every owner has a `:default` desk — and SupportDesk::Current.owner says
+  # whose is meant. A desk with no owner is the single-desk app.
   class Desk < ApplicationRecord
     self.table_name = "support_desk_desks"
 
+    belongs_to :owner, polymorphic: true, optional: true
+
+    # nil, rather than a MissingAttributeError, until the 0.6 migration has
+    # added the column: an unmigrated install has no owners.
+    def owner = has_attribute?(:owner_id) ? super : nil
+
     acts_as_messager notifications: false,
                      blockable: false,
                      inbox: :grouped,
@@ -50,14 +61,35 @@ module SupportDesk
     # written once in its life — and it is why configuration, not
     # `settings`, is the place to put anything that has to change together
     # everywhere.
-    def self.for(key)
+    def self.for(key, owner: nil)
       key = key.to_s
-      find_by(key: key) || create_or_find_by!(key: key)
+      scope = owned_by(owner)
+      scope.find_by(key: key) || scope.create_or_find_by!(key: key)
     end
 
-    # This desk's slice of the configuration.
+    # The desks that belong to +owner+; nil means the desks that belong to
+    # nobody. Before the 0.6 migration there is no owner to ask about, and
+    # every desk belongs to nobody.
+    def self.owned_by(owner)
+      return all if owner.nil? && !column_names.include?("owner_id")
+
+      where(owner: owner)
+    end
+
+    # This desk's slice of the configuration: the initializer's, overlaid
+    # with what `config.desk_settings` says about this row when the host
+    # set one. Read once per record — see SupportDesk.desk for how long a
+    # record lives.
     def config
-      SupportDesk.config.desk(key)
+      return SupportDesk.config.desk(key) if SupportDesk.config.desk_settings.nil?
+
+      @config ||= SupportDesk.config.desk_configuration_for(self)
+    end
+
+    # A reloaded desk reads its settings again.
+    def reload(*)
+      @config = nil
+      super
     end
 
     # What requesters see as the counterpart. Configuration wins; the
@@ -79,13 +111,14 @@ module SupportDesk
       config.read(:email) || settings["email"].presence
     end
 
-    # The assistant who works this desk, or nil. Resolved through
+    # The assistant who works this desk, or nil: the one with this desk's
+    # owner, whatever SupportDesk::Current.owner says. Resolved through
     # `SupportDesk.assistant`, so it is the same memoised record everywhere.
     def assistant
       key = config.assistant_key
       return nil if key.nil?
 
-      SupportDesk.assistant(key)
+      SupportDesk.assistant(key, owner: owner)
     end
 
     # Whether this desk has one at all.
@@ -124,7 +157,7 @@ module SupportDesk
 
     # The desk, in one line.
     def inspect
-      "#<SupportDesk::Desk #{key} #{name.inspect}>"
+      "#<SupportDesk::Desk #{key} #{name.inspect}#{" #{owner_type}##{owner_id}" if try(:owner_id)}>"
     end
   end
 end

data/lib/support_desk/models/event.rb

@@ -8,6 +8,13 @@ module SupportDesk
   # describe — exactly one row per transition — and are read-only forever
   # after. Hosts with tamper-evident logs mirror them by subscribing to
   # `:ticket_transitioned` rather than by writing here.
+  #
+  # Two kinds are not transitions but SIGNALS, written in the transaction
+  # that produced them so a durable reader (SupportDesk::Events.replay) sees
+  # them even when the process dies before the in-memory event fires:
+  # `assistant_turn` (there is something for the assistant to answer, at
+  # this turn) and `draft_proposed`. Neither is history, so neither is in
+  # the timeline.
   class Event < ApplicationRecord
     self.table_name = "support_desk_events"
 
@@ -15,15 +22,20 @@ module SupportDesk
       opened assigned handed_off released drop_in closed reopened topic_changed subject_attached note
       snoozed woken escalated channel_added email_bounced email_unverified rated tagged
       human_requested assistant_paused assistant_resumed draft_sent draft_rejected assistant_withheld
+      assistant_turn draft_proposed
     ].freeze
 
-    # The five kinds that describe how the desk works rather than what
+    # The kinds that say "something is now owed", not "something happened".
+    SIGNAL_KINDS = %w[assistant_turn draft_proposed].freeze
+
+    # The kinds that describe how the desk works rather than what
     # happened to the case. They join `note` and `drop_in` outside
     # #requester_visible: a customer's export says a person was asked for
     # (`escalated`, `human_requested`), never that a machine's proposal was
     # discarded.
     INTERNAL_KINDS = %w[
       note drop_in assistant_paused assistant_resumed draft_sent draft_rejected assistant_withheld
+      assistant_turn draft_proposed
     ].freeze
 
     belongs_to :ticket, class_name: "SupportDesk::Ticket", inverse_of: :events
@@ -39,6 +51,8 @@ module SupportDesk
     # Everything a requester may see in an export: their own case's story,
     # never the desk's internal reasoning.
     scope :requester_visible, -> { where.not(kind: INTERNAL_KINDS) }
+    # What happened to the case, without the signals — what a timeline shows.
+    scope :history, -> { where.not(kind: SIGNAL_KINDS) }
 
     # Write one event. `actor` may be a record or a Symbol (`:system`,
     # `:routing`) — symbols are kept in the payload, since there is no row