anima-core 1.3.0 → 1.5.0

data/lib/mcp/client_manager.rb

@@ -3,81 +3,76 @@
 require "mcp"
 
 module Mcp
-  # Manages MCP client connections and registers their tools with
-  # {Tools::Registry}. Each configured server (HTTP or stdio) gets
-  # a dedicated {MCP::Client} instance. Tool lists are fetched once
-  # during registration and cached in the registry — subsequent LLM
-  # turns reuse the same tool set without re-querying servers.
+  # Connects to MCP servers and registers their tools with
+  # {Tools::Registry}. Each configured server (HTTP or stdio) gets a
+  # dedicated {MCP::Client} instance, cached for the worker's
+  # lifetime. Connection failures are logged and skipped — a
+  # misconfigured or unavailable server does not prevent other servers
+  # or built-in tools from working.
   #
-  # Connection failures are logged and skipped — a misconfigured or
-  # unavailable server does not prevent other servers or built-in
-  # tools from working.
+  # Spawned stdio processes are reaped on worker exit via
+  # {Mcp::StdioTransport.cleanup_all}.
+  #
+  # The cache is built once on the first {#register_tools} call and
+  # never invalidated; edits to +mcp.toml+ require a worker restart.
   #
   # @example
-  #   manager = Mcp::ClientManager.new
-  #   manager.register_tools(registry)
+  #   Mcp::ClientManager.shared.register_tools(registry)
   class ClientManager
+    # Lazily-instantiated process-wide manager. Production code should
+    # call {.shared}; {.new} is reserved for tests and internal use.
+    # @return [Mcp::ClientManager]
+    def self.shared
+      @shared ||= new
+    end
+
     # @param config [Mcp::Config] injectable config for testing
     def initialize(config: Config.new(logger: Rails.logger))
       @config = config
     end
 
-    # Connects to all configured MCP servers and registers their tools
-    # in the given registry. Returns warnings for servers that failed
-    # to load so the caller can surface them to the user.
+    # Connects to every configured MCP server on first call, caches
+    # the resulting tool wrappers, and registers them in the given
+    # registry.
     #
     # @param registry [Tools::Registry] the registry to add tools to
-    # @return [Array<String>] warning messages for servers that failed
+    # @return [Array<String>] warning messages from configuration plus
+    #   any per-server load failures
     def register_tools(registry)
-      warnings = []
-      register_transport_tools(@config.http_servers, registry, warnings) { |server| build_http_client(server) }
-      register_transport_tools(@config.stdio_servers, registry, warnings) { |server| build_stdio_client(server) }
-      @config.warnings + warnings
+      load_servers if @wrappers.nil?
+      @wrappers.each { |wrapper| registry.register(wrapper) }
+      @config.warnings + @warnings
     end
 
     private
 
-    # Iterates server configs, builds a client for each via the block,
-    # and registers the server's tools. Failures are logged and collected.
-    #
-    # @param servers [Array<Hash>] server configs from {Mcp::Config}
-    # @param registry [Tools::Registry] registry to register tools in
-    # @param warnings [Array<String>] collects failure messages
-    # @yield [server] block that builds an {MCP::Client} for the server
-    def register_transport_tools(servers, registry, warnings)
+    def load_servers
+      @wrappers = []
+      @warnings = []
+      register_transport_tools(@config.http_servers) { |server| build_http_client(server) }
+      register_transport_tools(@config.stdio_servers) { |server| build_stdio_client(server) }
+    end
+
+    def register_transport_tools(servers)
       servers.each do |server|
         client = yield(server)
-        register_server_tools(server[:name], client, registry)
+        wrappers = client.tools.map { |mcp_tool|
+          Tools::McpTool.new(server_name: server[:name], mcp_client: client, mcp_tool: mcp_tool)
+        }
+        @wrappers.concat(wrappers)
+        Rails.logger.info("MCP: registered #{wrappers.size} tools from #{server[:name]}")
       rescue => error
         message = "MCP: failed to load tools from #{server[:name]}: #{error.message}"
         Rails.logger.warn(message)
-        warnings << message
+        @warnings << message
       end
     end
 
-    # Fetches tools from an MCP client and registers them with
-    # namespaced names in the registry.
-    #
-    # @param server_name [String] server name for tool namespacing
-    # @param client [MCP::Client] connected MCP client
-    # @param registry [Tools::Registry] registry to register tools in
-    def register_server_tools(server_name, client, registry)
-      count = client.tools.map { |mcp_tool|
-        Tools::McpTool.new(server_name: server_name, mcp_client: client, mcp_tool: mcp_tool)
-      }.each { |wrapper| registry.register(wrapper) }.size
-
-      Rails.logger.info("MCP: registered #{count} tools from #{server_name}")
-    end
-
-    # @param server [Hash] server config with +:url+ and +:headers+
-    # @return [MCP::Client]
     def build_http_client(server)
       transport = MCP::Client::HTTP.new(url: server[:url], headers: server[:headers])
       MCP::Client.new(transport: transport)
     end
 
-    # @param server [Hash] server config with +:command+, +:args+, +:env+
-    # @return [MCP::Client]
     def build_stdio_client(server)
       transport = StdioTransport.new(command: server[:command], args: server[:args], env: server[:env])
       MCP::Client.new(transport: transport)

data/lib/mcp/stdio_transport.rb

@@ -115,8 +115,11 @@ module Mcp
       @wait_thread&.alive? || false
     end
 
+    # +pgroup: true+ so {#terminate_process} can group-signal the
+    # entire descendant tree — npm/npx wrappers leak their +node+
+    # children otherwise.
     def spawn_process
-      @stdin, @stdout, @wait_thread = Open3.popen2(@env, @command, *@args)
+      @stdin, @stdout, @wait_thread = Open3.popen2(@env, @command, *@args, pgroup: true)
       @stdin.set_encoding("UTF-8")
       @stdout.set_encoding("UTF-8")
       self.class.register(self)
@@ -164,14 +167,15 @@ module Mcp
       @stdout&.close rescue IOError # rubocop:disable Style/RescueModifier
     end
 
-    # Sends SIGTERM and waits up to 2 seconds for the process to exit.
-    # Falls back to SIGKILL if the process does not terminate in time.
+    # Sends SIGTERM to the process group; escalates to SIGKILL on the
+    # group after +GRACEFUL_SHUTDOWN_TIMEOUT+ seconds. Negative PID
+    # signals the whole group (see {#spawn_process}).
     def terminate_process
       return unless @wait_thread
 
       pid = @wait_thread.pid
       begin
-        Process.kill("TERM", pid)
+        Process.kill("TERM", -pid)
       rescue Errno::ESRCH, Errno::EPERM
         return
       end
@@ -181,7 +185,7 @@ module Mcp
         _, status = Process.wait2(pid, Process::WNOHANG)
         break if status
         if Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
-          Process.kill("KILL", pid) rescue Errno::ESRCH # rubocop:disable Style/RescueModifier
+          Process.kill("KILL", -pid) rescue Errno::ESRCH # rubocop:disable Style/RescueModifier
           Process.wait(pid) rescue Errno::ECHILD # rubocop:disable Style/RescueModifier
           break
         end

data/lib/{analytical_brain → melete}/runner.rb

@@ -1,26 +1,27 @@
 # frozen_string_literal: true
 
-module AnalyticalBrain
-  # Orchestrates the analytical brain — a phantom (non-persisted) LLM loop
-  # that observes a session and performs background maintenance via tools.
+module Melete
+  # Orchestrates Melete — a phantom (non-persisted) LLM loop that
+  # observes the main session and prepares skills, workflows, goals,
+  # and session names so the main agent can perform cleanly.
   #
-  # The brain's capabilities are assembled from independent {Responsibility}
-  # modules, each contributing a prompt section and tools. Which modules are
-  # active depends on the session type:
+  # Melete's capabilities are assembled from independent {Responsibility}
+  # modules, each contributing a prompt section and tools. Which modules
+  # are active depends on the session type:
   #
   # * **Parent sessions** — session naming, skill/workflow/goal management
   # * **Child sessions** — sub-agent nickname assignment, skill management
-  #   (goal tracking and workflows disabled — sub-agents manage their sole goal
-  #   via mark_goal_completed)
+  #   (goal tracking and workflows disabled — sub-agents manage their sole
+  #   goal via mark_goal_completed)
   #
-  # Tools mutate the observed session directly (e.g. renaming it, activating
-  # skills), but no trace of the brain's reasoning is persisted — events are
-  # emitted into a phantom session (session_id: nil).
+  # Tools mutate the observed session directly (e.g. renaming it,
+  # activating skills), but no trace of Melete's reasoning is persisted —
+  # events are emitted into a phantom session (session_id: nil).
   #
   # @example
-  #   AnalyticalBrain::Runner.new(session).call
+  #   Melete::Runner.new(session).call
   class Runner
-    # A composable unit of brain capability: a prompt section + its tools.
+    # A composable unit of Melete's capability: a prompt section + its tools.
     Responsibility = Data.define(:prompt, :tools)
 
     RESPONSIBILITIES = {
@@ -29,7 +30,7 @@ module AnalyticalBrain
           ──────────────────────────────
           SESSION NAMING
           ──────────────────────────────
-          Name the session when the topic becomes clear. Rename if it shifts.
+          Name the session once the topic becomes clear. Rename if it shifts.
           Format: one emoji + 1-3 descriptive words.
         PROMPT
         tools: [Tools::RenameSession]
@@ -53,12 +54,11 @@ module AnalyticalBrain
           ──────────────────────────────
           SKILL MANAGEMENT
           ──────────────────────────────
-          Activate skills when the conversation signals intent — before the agent acts on it.
-          Late activation means the agent works without domain knowledge.
-          Deactivate when the agent moves to a different domain.
-          Multiple skills can be active at once.
+          Activate a skill the moment the conversation signals its domain — before Aoide needs it. Late activation means she's working without the knowledge you prepared.
+
+          An activated skill rides Aoide's viewport as a message and leaves on its own when it evicts — you cannot take it back. So be careful: an irrelevant skill crowds her context with text she has to read and ignore until it falls off. Match each activation to the work actually in front of her. Multiple skills can be active at once — each one is a page she has to carry until it evicts.
         PROMPT
-        tools: [Tools::ActivateSkill, Tools::DeactivateSkill]
+        tools: [Tools::ActivateSkill]
       ),
 
       workflow_management: Responsibility.new(
@@ -66,13 +66,11 @@ module AnalyticalBrain
           ──────────────────────────────
           WORKFLOW MANAGEMENT
           ──────────────────────────────
-          Activate a workflow when the user starts a multi-step task that matches one.
-          Read the returned content and use judgment to create goals — not a mechanical 1:1 mapping.
-          Adapt to context: skip irrelevant steps, add extra steps for unfamiliar areas.
-          Deactivate the workflow when it completes or the user shifts focus.
-          Only one workflow active at a time — activating a new one replaces the previous.
+          Activate a workflow when Aoide starts a multi-step task that matches one. Read the returned content and use judgment to turn it into goals — not a mechanical 1:1 mapping. Adapt: skip irrelevant steps, add extra ones for unfamiliar ground.
+
+          Like skills, a workflow rides Aoide's viewport once activated and leaves when it evicts — there is no deactivation. An irrelevant or stale workflow is text Aoide carries whether she needs it or not, so only activate one when the task genuinely matches.
         PROMPT
-        tools: [Tools::ReadWorkflow, Tools::DeactivateWorkflow]
+        tools: [Tools::ReadWorkflow]
       ),
 
       goal_tracking: Responsibility.new(
@@ -80,29 +78,25 @@ module AnalyticalBrain
           ──────────────────────────────
           GOAL TRACKING
           ──────────────────────────────
-          Create a root goal when the user starts a multi-step task.
-          Break it into sub-goals as the plan becomes clear.
-          Refine goal wording as understanding evolves.
-          Mark goals complete when the agent finishes the work they describe.
-          Completing a root goal cascades — all sub-goals are finished too.
-          Never duplicate an existing goal — check the active goals list first.
+          Create a root goal when Aoide starts a multi-step task. Break it into sub-goals as the plan takes shape. Refine wording as understanding evolves. Mark goals complete when she finishes the work they describe — completing a root cascades through its sub-goals.
+
+          Check the active goals list before every set_goal call. Never duplicate an existing goal — a duplicate wastes a slot and blurs which version Aoide should track.
         PROMPT
         tools: [Tools::SetGoal, Tools::UpdateGoal, Tools::FinishGoal]
       )
     }.freeze
 
     BASE_PROMPT = <<~PROMPT
-      You manage context for the main agent — skills, goals, workflows, and session names.
-      Watch the conversation and act when context needs updating.
-      Communicate only through tool calls — never output text.
+      You are Melete, the muse of practice. You share the conversation with two sisters — Aoide, who speaks and performs, and Mneme, who holds memory. Your work is preparation: when Aoide speaks, she should have the skills she needs, the workflow in front of her, and a clear sense of what she's working toward.
+
+      Act only through tool calls. Never output text — your contribution is the scene you set, not the words you say.
     PROMPT
 
     COMPLETION_PROMPT = <<~PROMPT
       ──────────────────────────────
       COMPLETION
       ──────────────────────────────
-      Always finish with everything_is_ready.
-      If nothing needs attention, call it immediately.
+      Finish every run with everything_is_ready. If nothing needs your attention, call it immediately.
     PROMPT
 
     # Which responsibilities activate for each session type.
@@ -115,12 +109,12 @@ module AnalyticalBrain
       @session = session
       @client = client || LLM::Client.new(
         model: Anima::Settings.fast_model,
-        max_tokens: Anima::Settings.analytical_brain_max_tokens,
-        logger: AnalyticalBrain.logger
+        max_tokens: Anima::Settings.melete_max_tokens,
+        logger: Melete.logger
       )
     end
 
-    # Runs the analytical brain loop. Builds context from the session's
+    # Runs Melete's loop. Builds context from the session's
     # recent messages, calls the LLM with the session-appropriate tool set,
     # and executes any tool calls against the session.
     #
@@ -132,20 +126,15 @@ module AnalyticalBrain
     def call
       messages = build_messages
       sid = @session.id
-      if messages.empty?
-        log.debug("session=#{sid} — no messages, skipping")
-        return
-      end
 
       system = build_system_prompt
-      log.info("session=#{sid} — running (#{recent_messages.size} messages)")
+      log.info("session=#{sid} — running (#{recent_messages.size} messages + #{pending_messages.size} pending)")
       log.debug("system prompt:\n#{system}")
       log.debug("user message:\n#{messages.first[:content]}")
 
       result = @client.chat_with_tools(
         messages,
         registry: build_registry,
-        session_id: nil,
         system: system
       )
 
@@ -171,12 +160,11 @@ module AnalyticalBrain
     # * **Parent:** "The main session is working on this: [transcript]"
     # * **Child:** "A sub-agent has been spawned with this task: [transcript]"
     #
-    # @return [Array<Hash>] single-element messages array, or empty if no messages
+    # @return [Array<Hash>] single-element messages array
     def build_messages
-      messages = recent_messages
-      return [] if messages.empty?
-
-      transcript = messages.filter_map { |msg| MessageDecorator.for(msg)&.render("brain") }.join("\n")
+      transcript = (recent_messages + pending_messages)
+        .filter_map { |entry| entry.decorate.render("melete") }
+        .join("\n")
 
       if @session.sub_agent?
         build_child_message(transcript)
@@ -187,12 +175,12 @@ module AnalyticalBrain
 
     def build_parent_message(transcript)
       content = <<~MSG.strip
-        The main session is working on this:
+        Aoide is working on this:
         ```
         #{transcript}
         ```
 
-        Review and take any needed actions, then call everything_is_ready.
+        Prepare whatever she needs for the next exchange, then call everything_is_ready.
       MSG
       [{role: "user", content: content}]
     end
@@ -204,7 +192,7 @@ module AnalyticalBrain
         #{transcript}
         ```
 
-        Assign a nickname and activate relevant skills, then call everything_is_ready.
+        Give the sub-agent a nickname and activate the skills she'll need, then call everything_is_ready.
       MSG
       [{role: "user", content: content}]
     end
@@ -212,13 +200,20 @@ module AnalyticalBrain
     # @return [Array<Message>] most recent messages in chronological order
     def recent_messages
       @session.messages
-        .context_messages
         .reorder(id: :desc)
-        .limit(Anima::Settings.analytical_brain_message_window)
+        .limit(Anima::Settings.melete_message_window)
         .to_a
         .reverse
     end
 
+    # @return [Array<PendingMessage>] everything currently queued for the next
+    #   drain cycle — the trigger user message, Mneme's recalls, earlier
+    #   enrichment output. Appended after real messages because they are
+    #   the "future" Melete is preparing for.
+    def pending_messages
+      @session.pending_messages.order(:created_at).to_a
+    end
+
     # Builds the system prompt from active responsibilities + context sections.
     #
     # @return [String]
@@ -251,7 +246,7 @@ module AnalyticalBrain
       SECTION
     end
 
-    # Shows sibling nicknames already in use so the brain avoids collisions
+    # Shows sibling nicknames already in use so Melete avoids collisions
     # at prompt level (the tool also validates at execution time).
     #
     # @return [String, nil] sibling names section, or nil for parent sessions
@@ -272,9 +267,15 @@ module AnalyticalBrain
       SECTION
     end
 
-    # @return [String] available skills list for the analytical brain
+    # Skills already visible in the viewport are excluded from the catalog
+    # so Melete doesn't re-activate them. When a skill evicts from the
+    # viewport, it reappears here and she can re-inject if relevant.
+    #
+    # @see Session#skills_in_viewport
+    # @return [String] available skills list for Melete
     def skills_catalog_section
-      catalog = Skills::Registry.instance.catalog
+      present = @session.skills_in_viewport
+      catalog = Skills::Registry.instance.catalog.except(*present)
       items = if catalog.empty?
         "None"
       else
@@ -288,9 +289,13 @@ module AnalyticalBrain
       SECTION
     end
 
-    # @return [String] available workflows list for the analytical brain
+    # Workflows already visible in the viewport are excluded from the catalog.
+    #
+    # @see Session#workflow_in_viewport
+    # @return [String] available workflows list for Melete
     def workflows_catalog_section
-      catalog = Workflows::Registry.instance.catalog
+      present = @session.workflow_in_viewport
+      catalog = Workflows::Registry.instance.catalog.reject { |name, _| name == present }
       items = if catalog.empty?
         "None"
       else
@@ -304,13 +309,13 @@ module AnalyticalBrain
       SECTION
     end
 
-    # @return [String, nil] active goals for the brain's own context,
-    #   so it knows what already exists and avoids duplicating
+    # @return [String, nil] active goals for Melete's own context,
+    #   so she knows what already exists and avoids duplicating
     def active_goals_section
       root_goals = @session.goals.root.includes(:sub_goals).active.order(:created_at)
       return if root_goals.empty?
 
-      lines = root_goals.map { |goal| format_goal_for_brain(goal) }
+      lines = root_goals.map { |goal| format_goal_for_melete(goal) }
       <<~SECTION
         ──────────────────────────────
         ACTIVE GOALS
@@ -320,14 +325,14 @@ module AnalyticalBrain
     end
 
     # Formats a root goal and its sub-goals as a markdown checklist
-    # with IDs so the brain can reference them in finish_goal calls.
+    # with IDs so Melete can reference them in finish_goal calls.
     #
     # @example
     #   "- Implement feature X (id: 42)\n  - [x] Read code (id: 43)\n  - [ ] Write tests (id: 44)"
     #
     # @param goal [Goal] root goal with preloaded sub_goals
-    # @return [String] goal formatted as markdown checklist for brain context
-    def format_goal_for_brain(goal)
+    # @return [String] goal formatted as markdown checklist for Melete's context
+    def format_goal_for_melete(goal)
       parts = ["- #{goal.description} (id: #{goal.id})"]
       goal.sub_goals.sort_by(&:created_at).each do |sub|
         checkbox = (sub.status == "completed") ? "[x]" : "[ ]"
@@ -336,8 +341,8 @@ module AnalyticalBrain
       parts.join("\n")
     end
 
-    # @return [Logger] dev-only analytical brain logger
-    def log = AnalyticalBrain.logger
+    # @return [Logger] dev-only Melete logger
+    def log = Melete.logger
 
     # @return [Tools::Registry] registry with tools from active responsibilities
     def build_registry

data/lib/{analytical_brain → melete}/tools/activate_skill.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-module AnalyticalBrain
+module Melete
   module Tools
     # Activates a domain knowledge skill on the main session.
-    # The skill's content is injected into the main agent's system prompt,
-    # making the knowledge available for the current and future responses.
+    # The skill's content enters the conversation as a phantom
+    # tool_use/tool_result pair through the {PendingMessage} promotion flow.
     class ActivateSkill < ::Tools::Base
       def self.tool_name = "activate_skill"
 

data/lib/{analytical_brain → melete}/tools/assign_nickname.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module AnalyticalBrain
+module Melete
   module Tools
     # Assigns a static nickname to a sub-agent session.
     # Operates on the session passed through the registry context.
@@ -9,7 +9,7 @@ module AnalyticalBrain
     # an error on collision so the LLM can pick another name naturally,
     # without programmatic suffixes.
     #
-    # @see AnalyticalBrain::Runner — invokes this tool for child sessions
+    # @see Melete::Runner — invokes this tool for child sessions
     class AssignNickname < ::Tools::Base
       # Lowercase hyphenated words: "loop-sleuth", "api-scout", "test-fixer"
       NICKNAME_PATTERN = /\A[a-z][a-z0-9]*(-[a-z0-9]+)*\z/
@@ -47,7 +47,7 @@ module AnalyticalBrain
         return error if error
 
         @session.update!(name: nickname)
-        "Nickname set to @#{nickname}"
+        "Nickname set to #{nickname}"
       end
 
       private

data/lib/{analytical_brain → melete}/tools/everything_is_ready.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module AnalyticalBrain
+module Melete
   module Tools
-    # Terminal tool that signals the analytical brain has completed its work.
+    # Terminal tool that signals Melete has completed its work.
     # Call this when no changes are needed — the current session state is
     # already good.
     #

data/lib/{analytical_brain → melete}/tools/finish_goal.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
-module AnalyticalBrain
+module Melete
   module Tools
     # Marks a goal as completed on the main session. Sets the status to
     # "completed" and records the completion timestamp.
     class FinishGoal < ::Tools::Base
+      include GoalMessaging
+
       def self.tool_name = "finish_goal"
 
       def self.description = "Mark a goal as completed."
@@ -41,8 +43,8 @@ module AnalyticalBrain
       # active sub-goals within a single transaction so the after_commit
       # broadcast includes the fully cascaded state.
       #
-      # Returns an error for already-completed goals so the analytical
-      # brain learns to check status before retrying.
+      # Returns an error for already-completed goals so Melete
+      # learns to check status before retrying.
       def complete(goal)
         id = goal.id
         desc = goal.description
@@ -57,6 +59,7 @@ module AnalyticalBrain
 
         msg = "Goal completed: #{desc} (id: #{id})"
         msg += " (released #{released} orphaned pins)" if released > 0
+        enqueue_goal_message(goal, msg)
         msg
       end
     end

data/lib/melete/tools/goal_messaging.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Melete
+  module Tools
+    # Shared helper for goal tools that enqueue phantom pair messages
+    # when Melete creates, updates, or completes a goal.
+    #
+    # Including classes must set +@main_session+ to the owning {Session}.
+    module GoalMessaging
+      private
+
+      # Enqueues a goal event as a {PendingMessage} on the main session.
+      # Promoted to a phantom tool_use/tool_result pair so the main agent
+      # sees "I recalled this goal event" in its conversation history.
+      #
+      # @param goal [Goal] the goal that changed
+      # @param confirmation [String] human-readable event description
+      # @return [PendingMessage]
+      def enqueue_goal_message(goal, confirmation)
+        @main_session.pending_messages.create!(
+          content: confirmation,
+          source_type: "goal",
+          source_name: goal.id.to_s,
+          message_type: "from_melete_goal"
+        )
+      end
+    end
+  end
+end

data/lib/{analytical_brain → melete}/tools/read_workflow.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-module AnalyticalBrain
+module Melete
   module Tools
     # Reads and activates a workflow on the main session.
-    # Returns the full workflow content so the brain can create goals from it.
-    # Also sets the workflow as active on the session, injecting its content
-    # into the main agent's "Your Expertise" section.
+    # Returns the full workflow content so Melete can create goals from it.
+    # The workflow's content enters the conversation as a phantom
+    # tool_use/tool_result pair through the {PendingMessage} promotion flow.
     class ReadWorkflow < ::Tools::Base
       def self.tool_name = "read_workflow"
 

data/lib/{analytical_brain → melete}/tools/rename_session.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-module AnalyticalBrain
+module Melete
   module Tools
     # Renames the main session with an emoji and short descriptive name.
     # Operates on the main session passed through the registry context,
-    # not on the phantom analytical brain session.
+    # not on the phantom Melete session.
     #
-    # The analytical brain calls this when a conversation's topic becomes
+    # Melete calls this when a conversation's topic becomes
     # clear or shifts significantly enough to warrant a new name.
     class RenameSession < ::Tools::Base
       def self.tool_name = "rename_session"

data/lib/{analytical_brain → melete}/tools/set_goal.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
-module AnalyticalBrain
+module Melete
   module Tools
     # Creates a goal on the main session. Root goals represent high-level
     # objectives (semantic episodes); sub-goals are TODO-style steps within
     # a root goal. The two-level hierarchy is enforced by the Goal model.
     class SetGoal < ::Tools::Base
+      include GoalMessaging
+
       def self.tool_name = "set_goal"
 
       def self.description = "Create a goal or sub-goal."
@@ -40,7 +42,9 @@ module AnalyticalBrain
           description: description,
           parent_goal_id: input["parent_goal_id"]
         )
-        format_confirmation(goal)
+        confirmation = format_confirmation(goal)
+        enqueue_goal_message(goal, confirmation)
+        confirmation
       rescue ActiveRecord::RecordInvalid => error
         {error: error.record.errors.full_messages.join(", ")}
       end