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

data/app/controllers/protege/agents_controller.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Protege
+  # Manages agent records — listing, creating, viewing, editing, and permanent deletion.
+  #
+  # An agent is the identity behind an inbox; the controller surfaces the full CRUD the dashboard
+  # needs. +destroy+ is the hard, irreversible removal (cascading all the agent's data); the
+  # reversible, history-preserving alternative is archiving — see +ArchivesController+.
+  class AgentsController < ApplicationController
+    before_action :set_agent, only: %i[show edit update destroy]
+
+    # List every agent. Serves +GET /agents+.
+    #
+    # @return [void]
+    def index
+      @agents = Agent.all
+    end
+
+    # Show a single agent. Serves +GET /agents/:id+.
+    #
+    # @return [void]
+    def show; end
+
+    # Render the form for creating an agent. Serves +GET /agents/new+.
+    #
+    # @return [void]
+    def new
+      @agent = Agent.new
+    end
+
+    # Render the form for editing an agent. Serves +GET /agents/:id/edit+.
+    #
+    # @return [void]
+    def edit; end
+
+    # Create an agent from the form's split email fields. Serves +POST /agents+.
+    #
+    # On failure, re-render the form with validation errors.
+    #
+    # @return [void]
+    def create
+      @agent = Agent.new(create_params)
+
+      if @agent.save
+        redirect_to agent_path(@agent), notice: 'Agent created.'
+      else
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    # Update an existing agent. Serves +PATCH /agents/:id+.
+    #
+    # On failure, re-render the edit form with validation errors.
+    #
+    # @return [void]
+    def update
+      if @agent.update(update_params)
+        redirect_to agent_path(@agent), notice: 'Agent updated.'
+      else
+        render :edit, status: :unprocessable_entity
+      end
+    end
+
+    # Permanently delete an agent and everything it owns. Serves +DELETE /agents/:id+.
+    #
+    # This is the hard, irreversible removal (the reversible path is Archive — see +ArchivesController+):
+    # the model cascades the agent's threads, messages, responsibilities, access rules, and tool-use
+    # history. +BroadcastableAgent+ removes its sidebar row.
+    #
+    # @return [void]
+    def destroy
+      @agent.destroy!
+
+      redirect_to agents_path, notice: 'Agent deleted.'
+    end
+
+    private
+
+    # Load the +Agent+ named by +params[:id]+ into +@agent+.
+    #
+    # @return [Protege::Agent] the loaded agent
+    def set_agent
+      @agent = Agent.find(params[:id])
+    end
+
+    # Permit creation attributes and fold the split email fields into a single address.
+    #
+    # @return [ActionController::Parameters] the permitted attributes plus +:email_address+
+    def create_params
+      params.require(:agent)
+            .permit(:type, :name, :instructions)
+            .merge(email_address: compose_email_address)
+    end
+
+    # Permit the editable attributes and recompose the address from the split email fields. Changing the
+    # address is allowed — only mail to the *old* address stops routing here; all history keys off
+    # +agent_id+, not the address. Tools are not edited here: they come from the toolkits attached to the
+    # agent (managed on its show page), not from a per-agent field.
+    #
+    # @return [ActionController::Parameters] the permitted attributes plus +:email_address+
+    def update_params
+      params.require(:agent)
+            .permit(:name, :instructions)
+            .merge(email_address: compose_email_address)
+    end
+
+    # Combine the split prefix + domain fields from the form into a single
+    # email address.
+    #
+    # @return [String] the +prefix@domain+ address with surrounding whitespace stripped
+    def compose_email_address
+      params[:agent].values_at(:email_prefix, :email_domain)
+                    .map(&:to_s)
+                    .map(&:strip)
+                    .join('@')
+    end
+  end
+end

data/app/controllers/protege/archives_controller.rb

@@ -1,51 +1,51 @@
 # frozen_string_literal: true
 
 module Protege
-  # Archives and unarchives a persona — the reversible, data-preserving alternative to permanent deletion.
+  # Archives and unarchives an agent — the reversible, data-preserving alternative to permanent deletion.
   #
-  # Archiving is modeled as an +archive+ resource on the persona: +create+ archives it (stamps
-  # +archived_at+), +destroy+ unarchives it (clears it). An archived persona stops receiving mail and
+  # Archiving is modeled as an +archive+ resource on the agent: +create+ archives it (stamps
+  # +archived_at+), +destroy+ unarchives it (clears it). An archived agent stops receiving mail and
   # running scheduled responsibilities, but all its history is kept and it can be restored at any time.
   #
-  # Both actions re-render the persona's action bar in place over Turbo (the sidebar row updates
-  # separately via +BroadcastablePersona+), falling back to a full redirect for non-Turbo requests.
+  # Both actions re-render the agent's action bar in place over Turbo (the sidebar row updates
+  # separately via +BroadcastableAgent+), falling back to a full redirect for non-Turbo requests.
   class ArchivesController < ApplicationController
-    include PersonaScoped
+    include AgentScoped
 
-    # Archive the persona. Serves +POST /personas/:persona_id/archive+.
+    # Archive the agent. Serves +POST /agents/:agent_id/archive+.
     #
     # @return [void]
     def create
-      @persona.archive!
+      @agent.archive!
 
-      respond_with_persona(notice: 'Persona archived — it no longer receives mail or runs scheduled tasks.')
+      respond_with_agent(notice: 'Agent archived — it no longer receives mail or runs scheduled tasks.')
     end
 
-    # Unarchive the persona. Serves +DELETE /personas/:persona_id/archive+.
+    # Unarchive the agent. Serves +DELETE /agents/:agent_id/archive+.
     #
     # @return [void]
     def destroy
-      @persona.unarchive!
+      @agent.unarchive!
 
-      respond_with_persona(notice: 'Persona restored.')
+      respond_with_agent(notice: 'Agent restored.')
     end
 
     private
 
-    # Replace the persona's action bar over Turbo, or redirect back to the persona for a full request.
+    # Replace the agent's action bar over Turbo, or redirect back to the agent for a full request.
     #
     # @param notice [String] the flash message for the redirect fallback
     # @return [void]
-    def respond_with_persona(notice:)
+    def respond_with_agent(notice:)
       respond_to do |format|
         format.turbo_stream do
           render turbo_stream: turbo_stream.replace(
-            helpers.dom_id(@persona, :actions),
-            partial: 'protege/personas/actions',
-            locals:  { persona: @persona }
+            helpers.dom_id(@agent, :actions),
+            partial: 'protege/agents/actions',
+            locals:  { agent: @agent }
           )
         end
-        format.html { redirect_to persona_path(@persona), notice: }
+        format.html { redirect_to agent_path(@agent), notice: }
       end
     end
   end

data/app/controllers/protege/home_controller.rb

@@ -4,7 +4,7 @@ module Protege
   # Serves the dashboard landing page mounted at the engine root.
   #
   # The page is static — it renders the +show+ view as the entry point into the
-  # Protege dashboard, from which operators navigate to personas, threads, and
+  # Protege dashboard, from which operators navigate to agents, threads, and
   # email domains.
   class HomeController < ApplicationController
     # Render the dashboard landing page. Serves +GET /+.

data/app/controllers/protege/messages_controller.rb

@@ -4,7 +4,7 @@ module Protege
   # Messages — the console email search and per-message delete, both keyed off the globally-unique
   # message, so neither is thread-scoped.
   #
-  # +index+ (+GET /messages+) is the cross-persona search view: query params filter the messages via
+  # +index+ (+GET /messages+) is the cross-agent search view: query params filter the messages via
   # +MessageSearch+ and the matches render in the sidebar, each linking to its thread. +destroy+
   # (+DELETE /messages/:id+) removes a single message by id.
   class MessagesController < ApplicationController

data/app/controllers/protege/replies_controller.rb

@@ -11,7 +11,7 @@ module Protege
     # Serves +POST /threads/:thread_id/reply+.
     #
     # The console acts as the sender; the reply is addressed to the thread's
-    # persona so the LOGI loop processes it as if it arrived over SMTP.
+    # agent so the LOGI loop processes it as if it arrived over SMTP.
     #
     # The new message inserts itself into the thread over Turbo (its +after_create_commit+ broadcast,
     # see +BroadcastableMessage+), so a Turbo request needs no body — it just returns +201 Created+, which
@@ -22,7 +22,7 @@ module Protege
     def create
       Gateway.accept_console_message(
         mail:        build_reply_mail,
-        persona:     @thread.persona,
+        agent:       @thread.agent,
         attachments: reply_params[:files] || []
       )
 
@@ -53,7 +53,7 @@ module Protege
 
       Gateway.build_outbound(
         from:        Protege.configuration.console_address,
-        to:          @thread.persona.email_address,
+        to:          @thread.agent.email_address,
         subject:     @thread.subject,
         body:        reply_params[:body],
         in_reply_to: messages.last&.message_id,

data/app/controllers/protege/responsibilities_controller.rb

@@ -2,8 +2,8 @@
 
 module Protege
   # Manages scheduled responsibilities — the Loop layer's dashboard CRUD. A top-level section (like
-  # Personas or Traces): responsibilities are listed across all personas, and each one names its owning
-  # persona in the form rather than carrying it in the URL.
+  # Agents or Traces): responsibilities are listed across all agents, and each one names its owning
+  # agent in the form rather than carrying it in the URL.
   class ResponsibilitiesController < ApplicationController
     before_action :set_responsibility, only: %i[show edit update destroy]
 
@@ -11,7 +11,7 @@ module Protege
     #
     # @return [void]
     def index
-      @responsibilities = Responsibility.includes(:persona)
+      @responsibilities = Responsibility.includes(:agent)
     end
 
     # Show a single responsibility and its recent runs.
@@ -31,7 +31,7 @@ module Protege
     # @return [void]
     def edit; end
 
-    # Create a responsibility (its persona is chosen in the form). On failure, re-render with errors.
+    # Create a responsibility (its agent is chosen in the form). On failure, re-render with errors.
     #
     # @return [void]
     def create
@@ -65,18 +65,18 @@ module Protege
 
     private
 
-    # Load the responsibility named by the route into +@responsibility+ (its persona via the association).
+    # Load the responsibility named by the route into +@responsibility+ (its agent via the association).
     #
     # @return [Protege::Responsibility] the loaded responsibility
     def set_responsibility
       @responsibility = Responsibility.find(params[:id])
     end
 
-    # Permit the editable responsibility attributes, including the +:persona_id+ the form now supplies.
+    # Permit the editable responsibility attributes, including the +:agent_id+ the form now supplies.
     #
     # @return [ActionController::Parameters] the permitted attributes
     def responsibility_params
-      params.require(:responsibility).permit(:persona_id, :name, :instructions, :schedule, :active)
+      params.require(:responsibility).permit(:agent_id, :name, :instructions, :schedule, :active)
     end
   end
 end

data/app/controllers/protege/threads_controller.rb

@@ -35,10 +35,10 @@ module Protege
     #
     # @return [void]
     def create
-      persona = Persona.find(compose_params[:persona_id])
+      agent = Agent.find(compose_params[:agent_id])
 
       message = Gateway.message(
-        to:          persona.email_address,
+        to:          agent.email_address,
         subject:     compose_params[:subject],
         body:        compose_params[:body],
         attachments: compose_params[:files] || []
@@ -67,9 +67,9 @@ module Protege
 
     # Permit the compose-form attributes for a new conversation.
     #
-    # @return [ActionController::Parameters] the permitted +:persona_id+, +:subject+, +:body+, +:files+
+    # @return [ActionController::Parameters] the permitted +:agent_id+, +:subject+, +:body+, +:files+
     def compose_params
-      params.require(:thread).permit(:persona_id, :subject, :body, files: [])
+      params.require(:thread).permit(:agent_id, :subject, :body, files: [])
     end
   end
 end

data/app/controllers/protege/toolkits_controller.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Protege
+  # Manages toolkits — the dashboard CRUD for the tool-bundle binding. A top-level section (like
+  # Responsibilities): toolkits are global, reusable tool bundles, attached to agents from the agent
+  # page. A toolkit is *just* its tools — permission (the sender gate + proactive flag) lives on each grant
+  # (+AgentToolkit+), so this controller only edits the name/description/tool set.
+  class ToolkitsController < ApplicationController
+    before_action :set_toolkit, only: %i[show edit update destroy]
+
+    # List every toolkit.
+    #
+    # @return [void]
+    def index
+      @toolkits = Toolkit.order(:name)
+    end
+
+    # Show a single toolkit and its gate rules.
+    #
+    # @return [void]
+    def show; end
+
+    # Render the form for creating a toolkit.
+    #
+    # @return [void]
+    def new
+      @toolkit = Toolkit.new
+    end
+
+    # Render the form for editing a toolkit.
+    #
+    # @return [void]
+    def edit; end
+
+    # Create a toolkit. On failure, re-render the form with validation errors.
+    #
+    # @return [void]
+    def create
+      @toolkit = Toolkit.new(toolkit_params)
+
+      if @toolkit.save
+        redirect_to toolkit_path(@toolkit), notice: 'Toolkit created.'
+      else
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    # Update a toolkit. On failure, re-render the edit form with validation errors.
+    #
+    # @return [void]
+    def update
+      if @toolkit.update(toolkit_params)
+        redirect_to toolkit_path(@toolkit), notice: 'Toolkit updated.'
+      else
+        render :edit, status: :unprocessable_entity
+      end
+    end
+
+    # Remove a toolkit (detaching it from every agent via the join's dependent destroy).
+    #
+    # @return [void]
+    def destroy
+      @toolkit.destroy
+      redirect_to toolkits_path, notice: 'Toolkit deleted.'
+    end
+
+    private
+
+    # Load the toolkit named by the route.
+    #
+    # @return [Protege::Toolkit] the loaded toolkit
+    def set_toolkit
+      @toolkit = Toolkit.find(params[:id])
+    end
+
+    # Permit the editable attributes. The member tools arrive as an array from the checklist; the gate
+    # rules are edited separately as child rows, so they are not permitted here.
+    #
+    # @return [ActionController::Parameters] the permitted attributes
+    def toolkit_params
+      params.require(:toolkit).permit(:name, :description, member_tool_ids: [])
+    end
+  end
+end

data/app/helpers/protege/agents_helper.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Protege
+  # View helpers for agent pages — selectors, labels, status, and resolver display.
+  module AgentsHelper
+    # List the loaded +Agent+ subclasses for the new-agent type selector.
+    #
+    # @return [Array<Class>] the +Agent+ descendant classes
+    def available_agent_types
+      Agent.descendants
+    end
+
+    # List active email domains for the agent form's domain selector.
+    #
+    # @return [ActiveRecord::Relation<Protege::EmailDomain>] domains eligible for selection
+    def available_email_domains
+      EmailDomain.all
+    end
+
+    # Fetch every +Agent+ ordered by name for sidebar listing.
+    #
+    # @return [ActiveRecord::Relation<Protege::Agent>] agents ordered alphabetically
+    def all_agents
+      Agent.order(:name)
+    end
+
+    # Format an agent's name together with its type for display.
+    #
+    #   agent_label(agent) # => "Bob <Executive Agent>"
+    #
+    # @param agent [Protege::Agent] the agent to label
+    # @return [String] the +"name <Type>"+ label
+    def agent_label(agent)
+      "#{agent.name} <#{agent.class.display_name}>"
+    end
+
+    # Render a status dot reflecting whether an agent is available.
+    #
+    # @param agent [Protege::Agent] the agent whose availability to show
+    # @return [ActiveSupport::SafeBuffer] a green dot when active, red otherwise
+    def agent_status(agent)
+      if agent.active?
+        status_dot('Available', :green)
+      else
+        status_dot('Unavailable', :red)
+      end
+    end
+
+    # Format an agent's resolver chain as a hash suitable for +info_card+ (rendered full-width, since
+    # the resolver class names are long). Each entry maps the resolver's short class name to a summary
+    # of its positional args, keyword args, and whether it was given a block.
+    #
+    # @param agent [Protege::Agent] the agent whose reply (+message_resolvers+) chain to format
+    # @return [Hash{String => String}] resolver-name => configuration summary
+    def resolver_pairs(agent)
+      pairs = agent.message_resolvers.entries.each_with_object({}) do |(klass, args, kwargs, block), accumulator|
+        accumulator[klass.name.demodulize] = resolver_config(args, kwargs, block)
+      end
+
+      pairs.any? ? pairs : { 'Resolvers' => 'None configured' }
+    end
+
+    private
+
+    # Summarize a resolver entry's positional args, keyword args, and whether it was given a block.
+    #
+    # @return [String] a comma-joined summary, or "" when the resolver takes no configuration
+    def resolver_config(args, kwargs, block)
+      parts  = args.map(&:inspect)
+      parts += kwargs.map { |key, value| "#{key}: #{value.inspect}" }
+      parts << '{ … }' if block
+      parts.join(', ')
+    end
+  end
+end

data/app/helpers/protege/application_helper.rb

@@ -8,16 +8,17 @@ module Protege
   # +Protege::Components::+ — pulled in as a whole via its own aggregator, +Components::ComponentsHelper+,
   # which includes the rest of the group (typography, tables, badges, buttons, cards, dialogs, menus,
   # forms, layout, sidebar, pagination, the introspection panel) — and the model-named helpers at the
-  # top level (threads, personas, email
+  # top level (threads, agents, email
   # domains, messages, responsibilities, traces). Any cross-helper call resolves through the view, which
   # has them all via this module.
   module ApplicationHelper
     include Components::ComponentsHelper
     include EmailDomainsHelper
     include MessagesHelper
-    include PersonasHelper
+    include AgentsHelper
     include ResponsibilitiesHelper
     include ThreadsHelper
+    include ToolkitsHelper
     include TraceHelper
 
     # List of JS files to be added to the console layout

data/app/helpers/protege/components/badges_helper.rb

@@ -10,13 +10,22 @@ module Protege
       #
       # @param text [String] the badge label
       # @param color [Symbol] the semantic color (see +badge_colors+)
+      # @param size [Symbol] +:md+ (default) or +:sm+ for a tinier pill (see +badge_size+)
       # @return [ActiveSupport::SafeBuffer] the badge markup
-      def badge(text, color = :gray)
+      def badge(text, color = :gray, size: :md)
         _, fg = badge_colors(color)
-        tag.span(text, class: "inline-flex items-center rounded px-1.5 py-0.5 text-xs font-medium #{fg}",
+        tag.span(text, class: "inline-flex items-center rounded font-medium #{badge_size(size)} #{fg}",
                        style: 'background: var(--surface-subtle); border: 1px solid var(--border)')
       end
 
+      # Map a badge size to its padding + text-size classes.
+      #
+      # @param size [Symbol] +:sm+ or +:md+
+      # @return [String] the sizing classes
+      def badge_size(size)
+        size == :sm ? 'px-1 py-px text-[10px]' : 'px-1.5 py-0.5 text-xs'
+      end
+
       # Map a semantic badge color to its +[background, foreground]+ classes.
       #
       # @param color [Symbol] the semantic color

data/app/helpers/protege/components/forms_helper.rb

@@ -75,13 +75,13 @@ module Protege
         end
       end
 
-      # Render the split prefix/domain email-address control for a persona.
+      # Render the split prefix/domain email-address control for an agent.
       #
       # When domains exist, render a prefix text box, an +@+ separator, and a domain
       # select preselected to the record's current domain; otherwise prompt the
       # operator to add a domain first.
       #
-      # @param record [Protege::Persona] the persona whose email address to edit
+      # @param record [Protege::Agent] the agent whose email address to edit
       # @param domains [Enumerable<Protege::EmailDomain>] the selectable domains
       # @return [ActiveSupport::SafeBuffer] the email-address control markup
       def form_email_address(record, domains)
@@ -138,16 +138,16 @@ module Protege
       # @param hint [String, nil] optional helper text shown beneath the label
       # @param value [Symbol, Proc] maps an item to its submitted value (default: +:to_s+)
       # @param text [Symbol, Proc] maps an item to its checkbox label (default: +:to_s+)
+      # @param description [Symbol, nil] reader for an item's secondary description; when given (and the
+      #   item answers it), each row stacks the label over a muted description line for scannability
       # @return [ActiveSupport::SafeBuffer] the checklist markup
-      def form_checklist(form, field, collection, label: nil, hint: nil, value: :to_s, text: :to_s)
+      def form_checklist(form, field, collection, label: nil, hint: nil, value: :to_s, text: :to_s, description: nil)
         tag.div do
           (label ? tag.label(label, class: FORM_LABEL) : ''.html_safe) +
             form_hint(hint) +
-            tag.div(class: 'space-y-2 pt-1') do
+            tag.div(class: 'space-y-2 mt-3') do
               form.collection_check_boxes(field, collection, value, text) do |b|
-                b.label(class: 'flex items-center gap-3 text-sm') do
-                  b.check_box(class: FORM_CHECKBOX, style: 'border: 1px solid var(--border)') + b.text
-                end
+                checklist_option(b, description)
               end
             end
         end
@@ -155,6 +155,41 @@ module Protege
 
       private
 
+      # Render a single checklist row: the checkbox and its label. With a +description+ reader, the label
+      # stacks the option name over a muted description line and top-aligns the box so multi-line rows read
+      # cleanly; without one, it falls back to a compact centered single line.
+      #
+      # @param builder [ActionView::Helpers::Tags::CollectionHelpers::Builder] the per-item builder
+      # @param description [Symbol, nil] reader for the option's description text
+      # @return [ActiveSupport::SafeBuffer] the labelled checkbox row
+      def checklist_option(builder, description)
+        desc      = description && builder.object.public_send(description).presence
+        # With a description the row is multi-line, so top-align it and nudge the box down to sit on the
+        # first text line; without one, a compact centered single line.
+        row_align = desc ? 'items-start' : 'items-center'
+        box_class = desc ? "#{FORM_CHECKBOX} mt-0.5" : FORM_CHECKBOX
+
+        builder.label(class: "flex #{row_align} gap-3 text-sm") do
+          builder.check_box(class: box_class, style: 'border: 1px solid var(--border)') +
+            checklist_option_body(builder, desc)
+        end
+      end
+
+      # Build the text beside a checklist checkbox: a plain label, or — when a description is present — the
+      # option name stacked over its muted description.
+      #
+      # @param builder [ActionView::Helpers::Tags::CollectionHelpers::Builder] the per-item builder
+      # @param desc [String, nil] the resolved description text, or nil for a plain label
+      # @return [ActiveSupport::SafeBuffer] the label body
+      def checklist_option_body(builder, desc)
+        return builder.text unless desc
+
+        tag.span(class: 'flex flex-col gap-0.5') do
+          tag.span(builder.text, class: 'font-medium') +
+            tag.span(desc, class: 'text-xs leading-snug', style: 'color: var(--text-faint)')
+        end
+      end
+
       # Render the muted hint paragraph shown beneath a field, or nothing.
       #
       # @param hint [String, nil] the hint text
@@ -167,7 +202,7 @@ module Protege
 
       # Render the prefix input, +@+ separator, and domain select for an address.
       #
-      # @param record [Protege::Persona] the persona whose address to edit
+      # @param record [Protege::Agent] the agent whose address to edit
       # @param domains [Enumerable<Protege::EmailDomain>] the selectable domains
       # @return [ActiveSupport::SafeBuffer] the prefix/separator/select markup
       def email_address_fields(record, domains)
@@ -180,13 +215,13 @@ module Protege
 
       # Render the local-part text input, seeded with the record's current prefix.
       #
-      # @param record [Protege::Persona] the persona whose prefix to seed
+      # @param record [Protege::Agent] the agent whose prefix to seed
       # @param input_base [String] the shared input classes without the +w-full+ utility
       # @return [ActiveSupport::SafeBuffer] the prefix input markup
       def email_address_prefix(record, input_base)
         tag.input(
           type:        'text',
-          name:        'persona[email_prefix]',
+          name:        'agent[email_prefix]',
           value:       record.email_address&.split('@')&.first,
           placeholder: 'alice',
           class:       "block w-40 #{input_base}",
@@ -196,7 +231,7 @@ module Protege
 
       # Render the domain select, preselecting the record's current domain.
       #
-      # @param record [Protege::Persona] the persona whose domain to preselect
+      # @param record [Protege::Agent] the agent whose domain to preselect
       # @param domains [Enumerable<Protege::EmailDomain>] the selectable domains
       # @param input_base [String] the shared input classes without the +w-full+ utility
       # @return [ActiveSupport::SafeBuffer] the domain select markup
@@ -206,7 +241,7 @@ module Protege
                                     selected: record.email_address&.end_with?("@#{domain.domain}"))
         end)
 
-        tag.select(options, name: 'persona[email_domain]', class: "block flex-1 #{input_base}",
+        tag.select(options, name: 'agent[email_domain]', class: "block flex-1 #{input_base}",
                             style: form_input_style)
       end
 

data/app/helpers/protege/components/typography_helper.rb

@@ -39,7 +39,7 @@ module Protege
       end
 
       # Render a block of verbatim body text — whitespace preserved, monospace — for content shown
-      # as-is, such as an email body or a persona's instructions. Escapes its input.
+      # as-is, such as an email body or an agent's instructions. Escapes its input.
       #
       # @param text [String] the text to render
       # @return [ActiveSupport::SafeBuffer] the preformatted text block

data/app/helpers/protege/messages_helper.rb

@@ -21,14 +21,14 @@ module Protege
       message.sent_at&.strftime('%-m/%-d/%y')
     end
 
-    # Render the sender line — persona name for outbound mail, local part of the
+    # Render the sender line — agent name for outbound mail, local part of the
     # address for inbound mail — followed by the full address.
     #
     # @param message [Protege::Message] the message to render the sender for
     # @return [ActiveSupport::SafeBuffer] the bold +"name <address>"+ span
     def message_sender(message)
       name = if message.outbound?
-               message.persona.name
+               message.agent.name
              else
                message.from_address.to_s.split('@').first
              end