protege 0.1.0.alpha.2 → 0.1.0.alpha.7

data/app/models/concerns/protege/toolable.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Protege
+  # An agent's tools — sourced entirely from the toolkits attached to it. There is no code-declared grant
+  # and no per-agent disable list: attaching a toolkit equips the agent with its member tools, and the
+  # attachment (+AgentToolkit+) decides who may reach them. Resolution is *fail-closed* — an agent with
+  # no attached toolkit has no tools at all, so even replying (send_email is itself a tool) requires a
+  # toolkit that supplies it.
+  #
+  # Two questions, two methods. {#available_tools} is the gate-agnostic union across every attached toolkit
+  # — the at-a-glance catalogue for the dashboard. {#available_tools_for} narrows that to a single run: a
+  # tool is offered only when some attached toolkit that contains it admits the run — on a reply the inbound
+  # sender must pass that grant's gate; on a scheduled (senderless) run the grant must opt into proactive
+  # use (fail-closed by default). Both reconcile against the live registry (via the toolkit's
+  # +member_tools+), so a stale member id — naming a tool since deleted from the code — is simply skipped.
+  module Toolable
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :agent_toolkits, class_name: 'Protege::AgentToolkit', dependent: :destroy
+      has_many :toolkits, through: :agent_toolkits
+
+      after_create :attach_default_toolkit
+    end
+
+    # The tool classes this agent may use for a specific run — the members of every attached toolkit whose
+    # grant admits the run, deduped. This is the single source of truth called by both the advertised
+    # catalogue and the dispatch backstop, so what the model is offered and what it is allowed to call can
+    # never diverge.
+    #
+    # @param context [Protege::Orchestrator::Context] the run context (its +message+/sender drives gating)
+    # @return [Array<Class>] the tool classes offered for this run
+    def available_tools_for(context:)
+      tool_classes(admitted_grants(context:))
+    end
+
+    # The ids of {#available_tools_for} — the convenience the dispatch backstop checks.
+    #
+    # @param context [Protege::Orchestrator::Context] the run context
+    # @return [Array<Symbol>] the offered tool ids
+    def available_tool_ids_for(context:)
+      available_tools_for(context:).map(&:id)
+    end
+
+    # Every tool this agent is equipped with across all attached toolkits, gate-agnostic — the at-a-glance
+    # catalogue for the dashboard. Who may actually reach each tool is decided per run by
+    # {#available_tools_for}; this answers only "what could this agent ever use".
+    #
+    # @return [Array<Class>] the union of the attached toolkits' tool classes
+    def available_tools
+      tool_classes(attachments)
+    end
+
+    # The ids of {#available_tools} — a convenience for UI and tests.
+    #
+    # @return [Array<Symbol>] the equipped tool ids
+    def available_tool_ids
+      available_tools.map(&:id)
+    end
+
+    private
+
+    # The attachments that admit this run — each grant whose gate the run passes.
+    #
+    # @param context [Protege::Orchestrator::Context] the run context
+    # @return [Array<Protege::AgentToolkit>] the admitting grants
+    def admitted_grants(context:)
+      attachments.select { |grant| grant_admits?(grant, context) }
+    end
+
+    # Whether one grant admits this run: the inbound sender must pass the grant's gate, or — with no sender
+    # (a scheduled run) — the grant must opt into proactive use.
+    #
+    # @param grant [Protege::AgentToolkit] the attachment
+    # @param context [Protege::Orchestrator::Context] the run context
+    # @return [Boolean] true when the grant admits the run
+    def grant_admits?(grant, context)
+      sender = context.message&.from_address
+      sender ? grant.permits?(sender:) : grant.allow_proactive?
+    end
+
+    # The reconciled, deduped tool classes across a set of grants. Each toolkit's +member_tools+ already
+    # drops ids with no registered tool, so a stale member can never conjure or break a tool.
+    #
+    # @param grants [Enumerable<Protege::AgentToolkit>] the grants to draw tools from
+    # @return [Array<Class>] the deduped tool classes
+    def tool_classes(grants)
+      grants.flat_map(&:member_tools).uniq(&:id).map(&:klass)
+    end
+
+    # The agent's toolkit grants with their toolkits eager-loaded — the single source read by resolution.
+    #
+    # @return [ActiveRecord::Relation<Protege::AgentToolkit>] the attachments
+    def attachments
+      agent_toolkits.includes(:toolkit)
+    end
+
+    # Give a freshly created agent its baseline tools by attaching the Default Tools system toolkit (with
+    # an open gate). A no-op before that toolkit has been synced into existence, so it never blocks
+    # creation — the agent simply starts with no tools until a toolkit is attached.
+    #
+    # @return [void]
+    def attach_default_toolkit
+      default = Toolkit.default_tools
+      agent_toolkits.create!(toolkit: default) if default
+    end
+  end
+end

data/app/models/protege/access_rule.rb

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
 
 module Protege
-  # One runtime allow/deny rule for a single persona — the dashboard-editable layer of the inbound
+  # One runtime allow/deny rule for a single agent — the dashboard-editable layer of the inbound
   # access-control guardrail. Each record carries a +kind+ (+allow+/+deny+) and an address +pattern+
-  # (an exact address or a +*+ wildcard such as +*@company.co+); together a persona's rules fold into
+  # (an exact address or a +*+ wildcard such as +*@company.co+); together an agent's rules fold into
   # a +Gateway::AccessPolicy+ via {.policy_for}.
   #
   # This is the *narrowing* layer: +AccessControl+ intersects it with the committed global policy
-  # (+Protege.configuration.inbound_access+), so a persona's rules can only further restrict who may
-  # reach that agent — never widen past the org-wide ceiling. A persona with no rules imposes no
+  # (+Protege.configuration.inbound_access+), so an agent's rules can only further restrict who may
+  # reach that agent — never widen past the org-wide ceiling. An agent with no rules imposes no
   # constraint of its own.
   class AccessRule < ApplicationRecord
     # ── Associations ────────────────────────────────────────────────────────
 
-    belongs_to :persona, class_name: 'Protege::Persona'
+    belongs_to :agent, class_name: 'Protege::Agent'
 
     # ── Attributes ──────────────────────────────────────────────────────────
 
@@ -28,17 +28,17 @@ module Protege
     # ── Class methods ───────────────────────────────────────────────────────
 
     class << self
-      # Fold one persona's rules into a single +Gateway::AccessPolicy+.
+      # Fold one agent's rules into a single +Gateway::AccessPolicy+.
       #
-      # Groups the persona's +allow+/+deny+ patterns into the policy's lists; the policy then derives
-      # its own default (an allow-list implies default-deny). A persona with no rules yields a bare
+      # Groups the agent's +allow+/+deny+ patterns into the policy's lists; the policy then derives
+      # its own default (an allow-list implies default-deny). An agent with no rules yields a bare
       # +Gateway::AccessPolicy+, which permits everyone and so drops out of the +AccessControl+
       # intersection.
       #
-      # @param persona [Protege::Persona] the persona whose rules to fold
-      # @return [Protege::Gateway::AccessPolicy] the persona's runtime access policy
-      def policy_for(persona)
-        grouped = where(persona:).group_by(&:kind)
+      # @param agent [Protege::Agent] the agent whose rules to fold
+      # @return [Protege::Gateway::AccessPolicy] the agent's runtime access policy
+      def policy_for(agent)
+        grouped = where(agent:).group_by(&:kind)
 
         Gateway.build_access_policy(
           allow: Array(grouped['allow']).map(&:pattern),

data/app/models/protege/{persona.rb → agent.rb}

@@ -1,54 +1,54 @@
 # frozen_string_literal: true
 
 module Protege
-  # Active Record base class for every Protege persona — the agent identity behind an email address.
+  # Active Record base class for every Protege agent — the agent identity behind an email address.
   #
-  # Personas are single-table-inheritance (STI) records: each concrete agent is a subclass defined
-  # in the host application and persisted in +protege_personas+, discriminated by the +type+ column.
-  # A persona owns the conversations addressed to it (+EmailThread+, +Message+) and declares the
+  # Agents are single-table-inheritance (STI) records: each concrete agent is a subclass defined
+  # in the host application and persisted in +protege_agents+, discriminated by the +type+ column.
+  # An agent owns the conversations addressed to it (+EmailThread+, +Message+) and declares the
   # resolver chain that the Orchestrator runs to build the inference context for each turn.
   #
   # The +email_address+ is operator-chosen and must line up with the host's MX records. Inbound
-  # routing supports RFC 5233 subaddressing: +alice+thread123@example.com+ routes to the persona
+  # routing supports RFC 5233 subaddressing: +alice+thread123@example.com+ routes to the agent
   # whose canonical address is +alice@example.com+ (see {.lookup}).
   #
-  # @example Define a persona in the host application
-  #   class Agent < Protege::Persona
-  #     self.display_name = 'AI Agent'
+  # @example Define an agent in the host application
+  #   class ExecutiveAgent < Protege::Agent
+  #     self.display_name = 'Executive Agent'
   #
   #     resolvers do |chain|
   #       chain.use Protege::ThreadHistoryResolver
   #     end
   #   end
-  class Persona < ApplicationRecord
-    self.table_name = 'protege_personas'
+  class Agent < ApplicationRecord
+    self.table_name = 'protege_agents'
 
-    # Keep the Personas sidebar live (append/replace/remove).
-    include BroadcastablePersona
+    # Keep the Agents sidebar live (append/replace/remove).
+    include BroadcastableAgent
 
-    # Narrow the tool catalogue per persona: the code-declared +tools+ grant minus the operator's
-    # +disabled_tool_ids+ override (see +ToolScoped+).
-    include ToolScoped
+    # The agent's tools, sourced entirely from the toolkits attached to it and gated per attachment —
+    # there is no code-declared grant (see +Toolable+, +Toolkit+, +AgentToolkit+).
+    include Toolable
 
     # ── Associations ──────────────────────────────────────────────────────────
 
     with_options dependent: :destroy do
-      # The persona's runtime inbound access rules — the dashboard-editable, narrowing layer of the
-      # access-control guardrail (see +AccessRule+ and +AccessControl+). Destroyed with the persona.
+      # The agent's runtime inbound access rules — the dashboard-editable, narrowing layer of the
+      # access-control guardrail (see +AccessRule+ and +AccessControl+). Destroyed with the agent.
       has_many :access_rules, class_name: 'Protege::AccessRule'
 
-      # Every email the persona has sent or received. Each +Message+ carries a denormalised
-      # +persona_id+, so this is the scoping seam for per-persona reads such as the +SearchEmailsTool+
-      # tool. Destroyed with the persona.
+      # Every email the agent has sent or received. Each +Message+ carries a denormalised
+      # +agent_id+, so this is the scoping seam for per-agent reads such as the +SearchEmailsTool+
+      # tool. Destroyed with the agent.
       has_many :messages, class_name: 'Protege::Message'
 
-      # The persona's standing, cron-scheduled duties — the Loop layer (see +Responsibility+). Dashboard
-      # CRUD is nested under the persona; runs the duty's +responsibility_resolvers+ chain. Destroyed
-      # with the persona.
+      # The agent's standing, cron-scheduled duties — the Loop layer (see +Responsibility+). Dashboard
+      # CRUD is nested under the agent; runs the duty's +responsibility_resolvers+ chain. Destroyed
+      # with the agent.
       has_many :responsibilities, class_name: 'Protege::Responsibility'
 
-      # Every conversation addressed to the persona. Carries a +persona_id+ FK with no DB-level cascade,
-      # so it must be destroyed with the persona (its messages cascade in turn) — otherwise a permanent
+      # Every conversation addressed to the agent. Carries a +agent_id+ FK with no DB-level cascade,
+      # so it must be destroyed with the agent (its messages cascade in turn) — otherwise a permanent
       # delete would orphan threads / raise a foreign-key error.
       has_many :email_threads, class_name: 'Protege::EmailThread'
     end
@@ -69,10 +69,10 @@ module Protege
 
     default_scope { order(:name) }
 
-    # Only personas currently enabled to receive and answer mail (i.e. not archived).
+    # Only agents currently enabled to receive and answer mail (i.e. not archived).
     scope :active,       -> { where(archived_at: nil) }
 
-    # Personas that have been archived (soft-removed): kept for history, out of routing.
+    # Agents that have been archived (soft-removed): kept for history, out of routing.
     scope :archived,     -> { where.not(archived_at: nil) }
 
     # ── Display name ────────────────────────────────────────────────────────
@@ -84,17 +84,17 @@ module Protege
     # ── Class methods ───────────────────────────────────────────────────────
 
     class << self
-      # Return the human-readable label for this persona subclass.
+      # Return the human-readable label for this agent subclass.
       #
       # Falls back to the demodulized class name when no explicit label has been set, so an
-      # unconfigured +Foo::Agent+ subclass reads as +"Agent"+.
+      # unconfigured +SupportAgent+ subclass reads as +"SupportAgent"+.
       #
       # @return [String, nil] the configured label, or the demodulized class name
       def display_name
         _display_name || name&.demodulize
       end
 
-      # Set the human-readable label for this persona subclass.
+      # Set the human-readable label for this agent subclass.
       #
       # @param val [String] the label to display in the UI
       # @return [String] the assigned label
@@ -130,7 +130,7 @@ module Protege
       # Return the resolver chain that assembles context for scheduled responsibility runs — the
       # proactive path (the Loop layer) — optionally mutating it in a block.
       #
-      # Held separately from the reply chain so a persona can present different context when acting on
+      # Held separately from the reply chain so an agent can present different context when acting on
       # its own initiative (e.g. a task prompt, no inbound thread) than when answering mail. Like the
       # reply chain it is lazily built and owned per subclass, never shared with the parent.
       #
@@ -153,15 +153,15 @@ module Protege
         self
       end
 
-      # Find the active persona that owns the given address, honouring subaddressing.
+      # Find the active agent that owns the given address, honouring subaddressing.
       #
       # Parses the address through +Gateway::Mail::Address+ and matches its +routing_key+ (the
       # tag-stripped, lowercased +local@domain+) against the canonical +email_address+. So
-      # +Alice+thread9@Example.com+ resolves to the persona at +alice@example.com+. Returns nil for
+      # +Alice+thread9@Example.com+ resolves to the agent at +alice@example.com+. Returns nil for
       # blank or malformed input.
       #
       # @param address [String, nil] the recipient address from an inbound email
-      # @return [Protege::Persona, nil] the matching active persona, or nil when none routes
+      # @return [Protege::Agent, nil] the matching active agent, or nil when none routes
       def lookup(address)
         active.find_by(email_address: Gateway.routing_key(address))
       rescue ArgumentError
@@ -171,52 +171,52 @@ module Protege
 
     # ── Instance methods ────────────────────────────────────────────────────
 
-    # Return this persona's resolver chains by delegating to the class-level chains — the reply chain
+    # Return this agent's resolver chains by delegating to the class-level chains — the reply chain
     # (+message_resolvers+) and the scheduled-run chain (+responsibility_resolvers+).
     #
-    # @return [Orchestrator::ResolverChain] the chain declared on this persona's subclass
+    # @return [Orchestrator::ResolverChain] the chain declared on this agent's subclass
     delegate :message_resolvers, :responsibility_resolvers, to: :class
 
     # ── Archive state ─────────────────────────────────────────────────────────
     # +active+/+archived+ are derived from +archived_at+ (no boolean column): +active?+ is what inbound
-    # routing (+.active+ scope, {.lookup}) and the status dot read, so archiving a persona removes it from
+    # routing (+.active+ scope, {.lookup}) and the status dot read, so archiving an agent removes it from
     # service while keeping all its history.
 
-    # Whether the persona is active (not archived).
+    # Whether the agent is active (not archived).
     #
     # @return [Boolean]
     def active?
       archived_at.nil?
     end
 
-    # Whether the persona has been archived (soft-removed): out of routing + scheduled runs, data kept.
+    # Whether the agent has been archived (soft-removed): out of routing + scheduled runs, data kept.
     #
     # @return [Boolean]
     def archived?
       archived_at.present?
     end
 
-    # Archive the persona — stops inbound routing and scheduled responsibility runs; data is preserved.
+    # Archive the agent — stops inbound routing and scheduled responsibility runs; data is preserved.
     #
     # @return [void]
     def archive!
       update!(archived_at: Time.current)
     end
 
-    # Return an archived persona to active service.
+    # Return an archived agent to active service.
     #
     # @return [void]
     def unarchive!
       update!(archived_at: nil)
     end
 
-    # Find one of this persona's own message attachments by its Active Storage attachment id.
+    # Find one of this agent's own message attachments by its Active Storage attachment id.
     #
-    # Scopes the lookup to attachments whose record is one of *this* persona's messages. The file tools
-    # now resolve by *blob* id (see +Protege::StoredFile.find+), so this persona-scoped lookup is
+    # Scopes the lookup to attachments whose record is one of *this* agent's messages. The file tools
+    # now resolve by *blob* id (see +Protege::StoredFile.find+), so this agent-scoped lookup is
     # currently unused by them — it is retained to become the scoping filter for the deferred
     # authorization pass (see the blob-currency spec §9). Returns +nil+ when the id is unknown or
-    # belongs to a different persona.
+    # belongs to a different agent.
     #
     # @param id [Integer, String] the +ActiveStorage::Attachment+ id
     # @return [ActiveStorage::Attachment, nil] the scoped attachment, or nil

data/app/models/protege/agent_toolkit.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Protege
+  # The grant binding one +Toolkit+ to one +Agent+ — and where the toolkit's permission lives. Giving a
+  # toolkit to an agent is not just "these tools are available"; it is "these tools are available to the
+  # senders I allow here". So the attachment carries the sender gate (its +agent_toolkit_rules+ folded
+  # into a +Gateway::AccessPolicy+, mirroring +AccessRule+) and +allow_proactive+ (whether the tools may
+  # run on this agent's scheduled, senderless runs). Two agents can attach the same toolkit and gate it
+  # differently.
+  class AgentToolkit < ApplicationRecord
+    # ── Associations ────────────────────────────────────────────────────────
+
+    belongs_to :agent, class_name: 'Protege::Agent'
+    belongs_to :toolkit, class_name: 'Protege::Toolkit'
+
+    has_many :agent_toolkit_rules, class_name: 'Protege::AgentToolkitRule', dependent: :destroy
+
+    # ── Validations ─────────────────────────────────────────────────────────
+
+    # A toolkit is attached to an agent at most once.
+    validates :toolkit_id, uniqueness: { scope: :agent_id }
+
+    # ── Delegation ────────────────────────────────────────────────────────────
+
+    # The tools this grant exposes come from the toolkit.
+    delegate :covers?, :member_tools, :name, to: :toolkit
+
+    # ── Instance methods ──────────────────────────────────────────────────────
+
+    # The sender gate for this grant as a policy, folded from its rules through the Gateway factory (never
+    # constructed by hand), mirroring +AccessRule.policy_for+. A grant with no rules permits everyone.
+    #
+    # @return [Protege::Gateway::AccessPolicy] the grant's gate
+    def access_policy
+      grouped = agent_toolkit_rules.group_by(&:kind)
+      Gateway.build_access_policy(
+        allow: Array(grouped['allow']).map(&:pattern),
+        deny:  Array(grouped['deny']).map(&:pattern)
+      )
+    end
+
+    # Whether a sender may unlock this grant's tools, per its gate.
+    #
+    # @param sender [String] the inbound sender's address
+    # @return [Boolean] true when the gate permits the sender
+    def permits?(sender:)
+      access_policy.permits?(address: sender)
+    end
+  end
+end

data/app/models/protege/agent_toolkit_rule.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Protege
+  # One allow/deny address rule for a toolkit grant's sender gate — the dashboard-editable pattern that
+  # decides which correspondents can unlock this agent's copy of a toolkit's tools. Belongs to the
+  # attachment (+AgentToolkit+), not the toolkit, so each grant is gated independently. Mirrors
+  # +AccessRule+: each row carries a +kind+ (+allow+/+deny+) and an address +pattern+ (an exact address or
+  # a +*+ wildcard such as +*@company.co+); the grant folds its rules into a +Gateway::AccessPolicy+ via
+  # {AgentToolkit#access_policy}.
+  class AgentToolkitRule < ApplicationRecord
+    # ── Associations ────────────────────────────────────────────────────────
+
+    belongs_to :agent_toolkit, class_name: 'Protege::AgentToolkit'
+
+    # ── Attributes ──────────────────────────────────────────────────────────
+
+    # Whether this rule admits (+allow+) or blocks (+deny+) matching senders.
+    enum :kind, { allow: 'allow', deny: 'deny' }
+
+    # ── Validations ─────────────────────────────────────────────────────────
+
+    # A rule with no pattern matches nothing and is meaningless; the address pattern is required.
+    validates :pattern, presence: true
+  end
+end

data/app/models/protege/application_record.rb

@@ -3,7 +3,7 @@
 module Protege
   # Abstract base class for every Active Record model in the Protege engine.
   #
-  # Every persisted model — +Persona+, +Message+, +EmailThread+, +EmailDomain+ — inherits
+  # Every persisted model — +Agent+, +Message+, +EmailThread+, +EmailDomain+ — inherits
   # from this class rather than +ActiveRecord::Base+ directly, mirroring the convention a host
   # Rails application uses for its own +ApplicationRecord+. Keeping a dedicated base class gives
   # the engine a single seam for shared concerns (connection handling, common scopes, callbacks)

data/app/models/protege/email_thread.rb

@@ -5,7 +5,7 @@ module Protege
   #
   # A thread is identified by its canonical +thread_id+: the RFC 2822 Message-ID of the conversation
   # root. For a reply that is the first entry of the References chain (falling back to In-Reply-To);
-  # for a brand-new conversation it is the message's own Message-ID. Threads belong to one +Persona+
+  # for a brand-new conversation it is the message's own Message-ID. Threads belong to one +Agent+
   # and carry denormalised counters (+message_count+, +last_message_at+) that +Message+ keeps fresh
   # so the inbox can sort and display without aggregating on every render.
   class EmailThread < ApplicationRecord
@@ -15,7 +15,7 @@ module Protege
 
     # ── Associations ────────────────────────────────────────────────────────
 
-    belongs_to :persona, class_name: 'Protege::Persona'
+    belongs_to :agent, class_name: 'Protege::Agent'
 
     # Destroying a thread removes its messages; inverse lets Message keep counters in sync. Each message
     # in turn destroys its own recorded tool uses (see +Message+), so a thread's tool history is torn
@@ -24,15 +24,16 @@ module Protege
 
     # ── Scopes ──────────────────────────────────────────────────────────────
 
-    # Eager-load persona and messages, most-recently-active first — the inbox listing query.
-    scope :for_inbox, -> { includes(:persona, :messages).order(last_message_at: :desc) }
+    # Eager-load agent and messages, most-recently-active first — the inbox listing query.
+    scope :for_inbox, -> { includes(:agent, :messages).order(last_message_at: :desc) }
 
     # ── Validations ─────────────────────────────────────────────────────────
 
     with_options presence: true do
-      # The canonical Message-ID must be unique so each conversation maps to one thread.
-      validates :thread_id, uniqueness: true
-      validates :persona
+      # The canonical Message-ID is unique per agent: each agent maps a conversation to its own thread,
+      # so one email to several proteges yields one thread each rather than colliding on a shared id.
+      validates :thread_id, uniqueness: { scope: :agent_id }
+      validates :agent
     end
 
     # ── Instance methods ─────────────────────────────────────────────────────
@@ -61,17 +62,19 @@ module Protege
           Gateway.canonical_message_id(mail.in_reply_to.presence || mail.message_id)
       end
 
-      # Find or create the thread for the given mail and persona.
+      # Find or create the thread for the given mail and agent.
       #
-      # On creation, seeds the persona, subject, and last-activity timestamp from the mail.
+      # On creation, seeds the agent, subject, and last-activity timestamp from the mail.
+      #
+      # Scoped to the agent: the same conversation reaching two agents resolves to a separate thread
+      # for each, since +thread_id+ is unique only within an agent.
       #
       # @param mail [Mail::Message] the email being threaded
-      # @param persona [Protege::Persona] the persona that owns the conversation
+      # @param agent [Protege::Agent] the agent that owns the conversation
       # @return [Protege::EmailThread] the existing or newly created thread
       # @raise [ActiveRecord::RecordInvalid] when a new thread fails validation
-      def find_or_create_for(mail:, persona:)
-        find_or_create_by!(thread_id: thread_id_for(mail)) do |t|
-          t.persona         = persona
+      def find_or_create_for(mail:, agent:)
+        find_or_create_by!(thread_id: thread_id_for(mail), agent:) do |t|
           t.subject         = mail.subject.to_s
           t.last_message_at = Time.current
         end