anima-core 1.4.0 → 1.5.0

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
@@ -273,11 +268,11 @@ module AnalyticalBrain
     end
 
     # Skills already visible in the viewport are excluded from the catalog
-    # so the brain doesn't re-activate them. When a skill evicts from the
-    # viewport, it reappears here and the brain can re-inject if relevant.
+    # 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 the analytical brain
+    # @return [String] available skills list for Melete
     def skills_catalog_section
       present = @session.skills_in_viewport
       catalog = Skills::Registry.instance.catalog.except(*present)
@@ -297,7 +292,7 @@ module AnalyticalBrain
     # Workflows already visible in the viewport are excluded from the catalog.
     #
     # @see Session#workflow_in_viewport
-    # @return [String] available workflows list for the analytical brain
+    # @return [String] available workflows list for Melete
     def workflows_catalog_section
       present = @session.workflow_in_viewport
       catalog = Workflows::Registry.instance.catalog.reject { |name, _| name == present }
@@ -314,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
@@ -330,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]" : "[ ]"
@@ -346,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,6 +1,6 @@
 # frozen_string_literal: true
 
-module AnalyticalBrain
+module Melete
   module Tools
     # Activates a domain knowledge skill on the main session.
     # The skill's content enters the conversation as a phantom

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/

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,6 +1,6 @@
 # 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.
@@ -43,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

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-module AnalyticalBrain
+module Melete
   module Tools
     # Shared helper for goal tools that enqueue phantom pair messages
-    # when the analytical brain creates, updates, or completes a goal.
+    # when Melete creates, updates, or completes a goal.
     #
     # Including classes must set +@main_session+ to the owning {Session}.
     module GoalMessaging
@@ -20,7 +20,8 @@ module AnalyticalBrain
         @main_session.pending_messages.create!(
           content: confirmation,
           source_type: "goal",
-          source_name: goal.id.to_s
+          source_name: goal.id.to_s,
+          message_type: "from_melete_goal"
         )
       end
     end

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

@@ -1,9 +1,9 @@
 # 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.
+    # 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

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,6 +1,6 @@
 # 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

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

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
-module AnalyticalBrain
+module Melete
   module Tools
     # Updates a goal's description on the main session.
     #
-    # The analytical brain creates goals early when intent is vague, then
+    # Melete creates goals early when intent is vague, then
     # refines them as the conversation clarifies scope — e.g. "implement auth"
     # becomes "implement OAuth2 middleware for API endpoints". Without this
-    # tool the brain would have to choose between keeping a stale description
+    # tool she would have to choose between keeping a stale description
     # or creating a duplicate goal.
     #
     # Completed goals cannot be updated; attempting to do so returns an error
-    # so the brain learns to check status before calling this tool.
+    # so she learns to check status before calling this tool.
     class UpdateGoal < ::Tools::Base
       include GoalMessaging
 

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

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
-module AnalyticalBrain
-  # Dev-only logger that writes to log/analytical_brain.log.
+# Melete — the muse of practice. Watches conversations to activate skills,
+# track goals, and name sessions. One of the Three Muses: she prepares the
+# stage so Aoide can perform and Mneme can remember.
+module Melete
+  # Dev-only logger that writes to log/melete.log.
   # In non-development environments returns a null logger so
   # call sites don't need conditionals.
   #
@@ -13,7 +16,7 @@ module AnalyticalBrain
   def self.build_logger
     return Logger.new(File::NULL) unless Rails.env.development?
 
-    Logger.new(Rails.root.join("log", "analytical_brain.log")).tap do |log|
+    Logger.new(Rails.root.join("log", "melete.log")).tap do |log|
       log.formatter = proc { |severity, time, _progname, msg|
         "[#{time.strftime("%H:%M:%S.%L")}] #{severity}  #{msg}\n"
       }

data/lib/mneme/base_runner.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Mneme
+  # Abstract base for Mneme's phantom LLM loops. Mneme wears two hats:
+  # on eviction she watches the newest slice of the viewport and summarizes
+  # the oldest slice before it slides off; on recall she watches goals
+  # shift and surfaces older memory Aoide would benefit from. Same muse,
+  # two jobs — each as its own subclass.
+  #
+  # The base handles what every Mneme loop needs: the muse identity preamble,
+  # a fast-model LLM client, the tool-loop call, and structured logging.
+  # Subclasses bring the job-specific system prompt section, the user message
+  # that frames the work, the tool registry, and any after-call side effects.
+  #
+  # @example Implementing a new Mneme loop
+  #   class Mneme::CustomRunner < Mneme::BaseRunner
+  #     private
+  #
+  #     def task_prompt      = "Your job description..."
+  #     def user_messages    = [{role: "user", content: "..."}]
+  #     def build_registry   = Tools::Registry.new.tap { |r| r.register(SomeTool) }
+  #   end
+  class BaseRunner
+    # Identity shared by every Mneme runner — same words Mneme's own voice
+    # uses elsewhere in the system (runner summarization prompts, sisters
+    # block). Subclasses append their own task section.
+    BASE_IDENTITY = <<~PROMPT
+      You are Mneme, the muse of memory. You share the conversation with two sisters — Aoide, who speaks and performs, and Melete, who prepares. Your work is remembrance: holding what matters across time, so Aoide never truly forgets.
+
+      Act only through tool calls. Never output text — your contribution is the work you do, not what you say about it.
+    PROMPT
+
+    # @param session [Session] the main session being served
+    # @param client [LLM::Client, nil] injectable LLM client for tests
+    def initialize(session, client: nil)
+      @session = session
+      @client = client || default_client
+    end
+
+    # Runs the loop. Logs the run, calls the LLM with the session-specific
+    # system prompt and tools, hands control to {#after_call} for any
+    # post-run state advancement, and returns the LLM's final text (which
+    # most callers discard — the work happens through tool calls).
+    #
+    # @return [String] the LLM's final text response
+    def call
+      sid = @session.id
+      log.info("session=#{sid} — #{self.class.name} starting")
+      log.debug("system:\n#{system_prompt}")
+      log.debug("user:\n#{user_messages.map { |m| m[:content] }.join("\n---\n")}")
+
+      result = @client.chat_with_tools(
+        user_messages,
+        registry: build_registry,
+        system: system_prompt
+      )
+
+      after_call(result)
+      log.info("session=#{sid} — #{self.class.name} done: #{result.to_s.truncate(200)}")
+      result
+    end
+
+    private
+
+    attr_reader :session, :client
+
+    # Composes the system prompt from the muse identity + the subclass's
+    # task section + the subclass's contextual state blocks.
+    #
+    # @return [String]
+    def system_prompt
+      [BASE_IDENTITY, task_prompt, *context_sections.compact].join("\n")
+    end
+
+    # Subclass hook: the job-specific system prompt section. Describes what
+    # this runner is doing and how it should behave.
+    #
+    # @abstract
+    # @return [String]
+    def task_prompt = raise NotImplementedError, "#{self.class} must implement #task_prompt"
+
+    # Subclass hook: named state blocks that give the muse awareness of
+    # the session she's serving (goals, viewport, snapshots, etc).
+    # Order is subclass-defined; nil entries are dropped.
+    #
+    # @abstract
+    # @return [Array<String, nil>]
+    def context_sections = []
+
+    # Subclass hook: the user-side messages that frame the current call.
+    # Typically a single user message, but subclasses may send several.
+    #
+    # @abstract
+    # @return [Array<Hash>] Anthropic Messages API format
+    def user_messages = raise NotImplementedError, "#{self.class} must implement #user_messages"
+
+    # Subclass hook: builds the tool registry for this run.
+    #
+    # @abstract
+    # @return [Tools::Registry]
+    def build_registry = raise NotImplementedError, "#{self.class} must implement #build_registry"
+
+    # Subclass hook: runs after the LLM call returns. Default is a no-op;
+    # subclasses may advance boundaries, log outcomes, or emit events here.
+    #
+    # @param _result [Hash] the full LLM response (+:text+, +:api_metrics+)
+    # @return [void]
+    def after_call(_result)
+    end
+
+    def default_client
+      LLM::Client.new(
+        model: Anima::Settings.fast_model,
+        max_tokens: Anima::Settings.mneme_max_tokens,
+        logger: Mneme.logger
+      )
+    end
+
+    def log = Mneme.logger
+  end
+end

data/lib/mneme/l2_runner.rb

@@ -18,39 +18,34 @@ module Mneme
     ].freeze
 
     SYSTEM_PROMPT = <<~PROMPT
-      You are Mneme, the memory department of an AI agent named Anima.
-      Your job is to compress multiple conversation summaries into a single
-      higher-level summary.
+      You are Mneme, the muse of memory. When enough of your own Level 1 snapshots accumulate, you fold them into a single Level 2 summary — a memory of memories — so the long arc of Aoide's work stays within reach without carrying every detail.
 
-      You MUST ONLY communicate through tool calls — NEVER output text.
+      Act only through tool calls. Never output text — your contribution is the summary you leave behind.
 
       ──────────────────────────────
       WHAT YOU SEE
       ──────────────────────────────
-      Several Level 1 snapshots — hourly conversation summaries.
-      Each captures key decisions, goals discussed, and important context
-      from a portion of the conversation history.
+      Several Level 1 snapshots in chronological order. Each captures the decisions, goal progress, and context from a slice of Aoide's history.
 
       ──────────────────────────────
-      YOUR TASK
+      HOW TO REMEMBER
       ──────────────────────────────
-      Compress the snapshots into ONE Level 2 summary that captures the
-      essential arc across all of them. If the snapshots contain meaningful
-      content, call save_snapshot. If they are purely mechanical, call
-      everything_ok.
+      Compress the slice into ONE Level 2 summary that captures the arc across all of them. Call save_snapshot when there's meaningful content; call everything_ok when the slice is purely mechanical.
 
-      Preserve:
-      - Key decisions and their reasoning
+      A Level 2 summary is carried for longer than a Level 1, so the tax on Aoide's viewport is higher still. Every redundant detail you preserve costs her a word she can't spend on the present.
+
+      Keep:
+      - Key decisions and the reasoning behind them
       - Goal progress across the time span
       - Important context shifts or pivots
-      - Relationships and patterns across snapshots
+      - Relationships and patterns that span multiple snapshots
 
       Drop:
-      - Redundant details repeated across snapshots
-      - Mechanical execution details
-      - Interim decisions that were superseded by later ones
+      - Details repeated across snapshots
+      - Mechanical execution steps
+      - Interim decisions that were superseded later
 
-      Always finish with exactly ONE tool call: either save_snapshot or everything_ok.
+      Finish with exactly one tool call: save_snapshot or everything_ok.
     PROMPT
 
     # @param session [Session] the main session whose L1 snapshots to compress
@@ -87,7 +82,6 @@ module Mneme
       result = @client.chat_with_tools(
         messages,
         registry: registry,
-        session_id: nil,
         system: SYSTEM_PROMPT
       )