anima-core 1.1.3 → 1.3.0

data/app/decorators/{event_decorator.rb → message_decorator.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-# Base decorator for {Event} records, providing multi-resolution rendering
-# for the TUI and analytical brain. Each event type has a dedicated subclass
+# Base decorator for {Message} records, providing multi-resolution rendering
+# for the TUI and analytical brain. Each message type has a dedicated subclass
 # that implements rendering methods for each view mode:
 #
 # - **basic** / **verbose** / **debug** — TUI display modes returning structured hashes
@@ -13,23 +13,23 @@
 # and formats it for display.
 #
 # Brain mode returns condensed single-line strings for the analytical brain's
-# event transcript. Returns nil to exclude an event from the brain's view.
+# message transcript. Returns nil to exclude a message from the brain's view.
 #
 # Subclasses must override {#render_basic}. Verbose, debug, and brain modes
 # delegate to basic until subclasses provide their own implementations.
 #
-# @example Decorate an Event AR model
-#   decorator = EventDecorator.for(event)
+# @example Decorate a Message AR model
+#   decorator = MessageDecorator.for(message)
 #   decorator.render_basic  #=> {role: :user, content: "hello"} or nil
 #
 # @example Render for a specific view mode
-#   decorator = EventDecorator.for(event)
+#   decorator = MessageDecorator.for(message)
 #   decorator.render("verbose")  #=> {role: :user, content: "hello", timestamp: 1709312325000000000}
 #
 # @example Decorate a raw payload hash (from EventBus)
-#   decorator = EventDecorator.for(type: "user_message", content: "hello")
+#   decorator = MessageDecorator.for(type: "user_message", content: "hello")
 #   decorator.render_basic  #=> {role: :user, content: "hello"}
-class EventDecorator < ApplicationDecorator
+class MessageDecorator < ApplicationDecorator
   delegate_all
 
   TOOL_ICON = "\u{1F527}"
@@ -46,36 +46,36 @@ class EventDecorator < ApplicationDecorator
   }.freeze
   private_constant :DECORATOR_MAP
 
-  # Normalizes hash payloads into an Event-like interface so decorators
-  # can use {#payload}, {#event_type}, etc. uniformly on both AR models
+  # Normalizes hash payloads into a Message-like interface so decorators
+  # can use {#payload}, {#message_type}, etc. uniformly on both AR models
   # and raw EventBus hashes.
   #
-  # @!attribute event_type [r] the event's type (e.g. "user_message")
-  # @!attribute payload [r] string-keyed hash of event data
+  # @!attribute message_type [r] the message's type (e.g. "user_message")
+  # @!attribute payload [r] string-keyed hash of message data
   # @!attribute timestamp [r] nanosecond-precision timestamp
   # @!attribute token_count [r] cumulative token count
-  EventPayload = Struct.new(:event_type, :payload, :timestamp, :token_count, keyword_init: true) do
-    # Heuristic token estimate matching {Event#estimate_tokens} so decorators
+  MessagePayload = Struct.new(:message_type, :payload, :timestamp, :token_count, keyword_init: true) do
+    # Heuristic token estimate matching {Message#estimate_tokens} so decorators
     # can call it uniformly on both AR models and hash payloads.
     # @return [Integer] at least 1
     def estimate_tokens
-      text = if event_type.to_s.in?(%w[tool_call tool_response])
+      text = if message_type.to_s.in?(%w[tool_call tool_response])
         payload.to_json
       else
         payload&.dig("content").to_s
       end
-      [(text.bytesize / Event::BYTES_PER_TOKEN.to_f).ceil, 1].max
+      [(text.bytesize / Message::BYTES_PER_TOKEN.to_f).ceil, 1].max
     end
   end
 
-  # Factory returning the appropriate subclass decorator for the given event.
-  # Hashes are normalized via {EventPayload} to provide a uniform interface.
+  # Factory returning the appropriate subclass decorator for the given message.
+  # Hashes are normalized via {MessagePayload} to provide a uniform interface.
   #
-  # @param event [Event, Hash] an Event AR model or a raw payload hash
-  # @return [EventDecorator, nil] decorated event, or nil for unknown types
-  def self.for(event)
-    source = wrap_source(event)
-    klass_name = DECORATOR_MAP[source.event_type]
+  # @param message [Message, Hash] a Message AR model or a raw payload hash
+  # @return [MessageDecorator, nil] decorated message, or nil for unknown types
+  def self.for(message)
+    source = wrap_source(message)
+    klass_name = DECORATOR_MAP[source.message_type]
     return nil unless klass_name
 
     klass_name.constantize.new(source)
@@ -92,8 +92,8 @@ class EventDecorator < ApplicationDecorator
   # Dispatches to the render method for the given view mode.
   #
   # @param mode [String] one of "basic", "verbose", "debug", "brain"
-  # @return [Hash, String, nil] structured event data (basic/verbose/debug),
-  #   plain string (brain), or nil to hide the event
+  # @return [Hash, String, nil] structured message data (basic/verbose/debug),
+  #   plain string (brain), or nil to hide the message
   # @raise [ArgumentError] if the mode is not a valid view mode
   def render(mode)
     method = RENDER_DISPATCH[mode]
@@ -102,29 +102,29 @@ class EventDecorator < ApplicationDecorator
     public_send(method)
   end
 
-  # @abstract Subclasses must implement to render the event for basic view mode.
-  # @return [Hash, nil] structured event data, or nil to hide the event
+  # @abstract Subclasses must implement to render the message for basic view mode.
+  # @return [Hash, nil] structured message data, or nil to hide the message
   def render_basic
     raise NotImplementedError, "#{self.class} must implement #render_basic"
   end
 
   # Verbose view mode with timestamps and tool details.
   # Delegates to {#render_basic} until subclasses provide their own implementations.
-  # @return [Hash, nil] structured event data, or nil to hide the event
+  # @return [Hash, nil] structured message data, or nil to hide the message
   def render_verbose
     render_basic
   end
 
   # Debug view mode with token counts and system prompts.
   # Delegates to {#render_basic} until subclasses provide their own implementations.
-  # @return [Hash, nil] structured event data, or nil to hide the event
+  # @return [Hash, nil] structured message data, or nil to hide the message
   def render_debug
     render_basic
   end
 
   # Analytical brain view — condensed single-line string for the brain's
-  # event transcript. Returns nil to exclude from the brain's context.
-  # Subclasses override to provide event-type-specific formatting.
+  # message transcript. Returns nil to exclude from the brain's context.
+  # Subclasses override to provide message-type-specific formatting.
   # @return [String, nil] formatted transcript line, or nil to skip
   def render_brain
     nil
@@ -132,7 +132,7 @@ class EventDecorator < ApplicationDecorator
 
   private
 
-  # Token count for display: exact count from {CountEventTokensJob} when
+  # Token count for display: exact count from {CountMessageTokensJob} when
   # available, heuristic estimate otherwise. Estimated counts are flagged
   # so the TUI can prefix them with a tilde.
   #
@@ -147,14 +147,14 @@ class EventDecorator < ApplicationDecorator
   end
 
   # Delegates to the underlying object's heuristic token estimator.
-  # Both {Event} AR models and {EventPayload} structs implement this.
+  # Both {Message} AR models and {MessagePayload} structs implement this.
   #
   # @return [Integer] at least 1
   def estimate_token_count
     object.estimate_tokens
   end
 
-  # Extracts display content from the event payload.
+  # Extracts display content from the message payload.
   # @return [String, nil]
   def content
     payload["content"]
@@ -190,14 +190,14 @@ class EventDecorator < ApplicationDecorator
   end
 
   # Normalizes input to something Draper can wrap.
-  # Event AR models pass through; hashes become EventPayload structs
+  # Message AR models pass through; hashes become MessagePayload structs
   # with string-normalized keys.
-  def self.wrap_source(event)
-    return event unless event.is_a?(Hash)
+  def self.wrap_source(message)
+    return message unless message.is_a?(Hash)
 
-    normalized = event.transform_keys(&:to_s)
-    EventPayload.new(
-      event_type: normalized["type"].to_s,
+    normalized = message.transform_keys(&:to_s)
+    MessagePayload.new(
+      message_type: normalized["type"].to_s,
       payload: normalized,
       timestamp: normalized["timestamp"],
       token_count: normalized["token_count"]&.to_i || 0

data/app/decorators/system_message_decorator.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-# Decorates system_message events for display in the TUI.
+# Decorates system_message records for display in the TUI.
 # Hidden in basic mode. Verbose and debug modes return timestamped system info.
-class SystemMessageDecorator < EventDecorator
+class SystemMessageDecorator < MessageDecorator
   # @return [nil] system messages are hidden in basic mode
   def render_basic
     nil

data/app/decorators/tool_call_decorator.rb

@@ -2,17 +2,17 @@
 
 require "toon"
 
-# Decorates tool_call events for display in the TUI.
+# Decorates tool_call records for display in the TUI.
 # Hidden in basic mode — tool activity is represented by the
 # aggregated tool counter instead. Verbose mode returns tool name
 # and a formatted preview of the input arguments. Debug mode shows
 # full untruncated input with tool_use_id — TOON format for most
-# tools, but write tool content preserves actual newlines.
+# tools, but write_file tool content preserves actual newlines.
 #
 # Think tool calls are special: "aloud" thoughts are shown in all
 # view modes (with a thought bubble), while "inner" thoughts are
 # visible only in verbose and debug modes.
-class ToolCallDecorator < EventDecorator
+class ToolCallDecorator < MessageDecorator
   THINK_TOOL = "think"
 
   # In basic mode, only "aloud" think calls are visible.
@@ -97,14 +97,14 @@ class ToolCallDecorator < EventDecorator
   def format_debug_input
     input = tool_input
     case payload["tool_name"]
-    when "write" then format_write_content(input)
+    when "write_file" then format_write_content(input)
     else Toon.encode(input)
     end
   end
 
   # Formats write tool input with file path header and content body.
   # Content newlines are preserved so the TUI can render them as
-  # separate lines, matching how read tool responses display file content.
+  # separate lines, matching how read_file tool responses display file content.
   # @param input [Hash] tool input hash with "file_path" and "content" keys
   # @return [String] path + content with real newlines, or TOON-encoded hash when content is empty
   def format_write_content(input)
@@ -125,7 +125,7 @@ class ToolCallDecorator < EventDecorator
       "$ #{input&.dig("command")}"
     when "web_get"
       "GET #{input&.dig("url")}"
-    when "read", "edit", "write"
+    when "read_file", "edit_file", "write_file"
       input&.dig("file_path").to_s
     else
       truncate_lines(Toon.encode(input), max_lines: 2)

data/app/decorators/tool_decorator.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 # Base class for server-side tool response decoration. Transforms raw tool
-# results into LLM-optimized formats before they enter the event stream.
+# results into LLM-optimized formats before they enter the message stream.
 #
-# This is a separate decorator type from {EventDecorator}: EventDecorator
-# formats events for clients (TUI/web), while ToolDecorator formats tool
+# This is a separate decorator type from {MessageDecorator}: MessageDecorator
+# formats messages for clients (TUI/web), while ToolDecorator formats tool
 # responses for the LLM. They sit at different points in the pipeline:
 #
-#   Tool executes → ToolDecorator transforms → event stream → EventDecorator renders
+#   Tool executes → ToolDecorator transforms → message stream → MessageDecorator renders
 #
 # Subclasses implement {#call} to transform a tool's raw result into an
 # LLM-friendly string. Each tool can have its own ToolDecorator subclass

data/app/decorators/tool_response_decorator.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Decorates tool_response events for display in the TUI.
+# Decorates tool_response records for display in the TUI.
 # Hidden in basic mode — tool activity is represented by the
 # aggregated tool counter instead. Verbose mode returns truncated
 # output with a success/failure indicator and tool name for per-tool
@@ -9,7 +9,7 @@
 #
 # Think tool responses ("OK") are hidden in basic and verbose modes
 # because the value is in the tool_call (the thoughts), not the response.
-class ToolResponseDecorator < EventDecorator
+class ToolResponseDecorator < MessageDecorator
   THINK_TOOL = "think"
 
   # @return [nil] tool responses are hidden in basic mode

data/app/decorators/user_message_decorator.rb

@@ -1,24 +1,17 @@
 # frozen_string_literal: true
 
-# Decorates user_message events for display in the TUI.
+# Decorates user_message records for display in the TUI.
 # Basic mode returns role and content. Verbose mode adds a timestamp.
 # Debug mode adds token count (exact when counted, estimated when not).
-# Pending messages include `status: "pending"` so the TUI renders them
-# with a visual indicator (dimmed, clock icon).
-class UserMessageDecorator < EventDecorator
-  # @return [Hash] structured user message data
-  #   `{role: :user, content: String}` or with `status: "pending"` when queued
+class UserMessageDecorator < MessageDecorator
+  # @return [Hash] structured user message data `{role: :user, content: String}`
   def render_basic
-    base = {role: :user, content: content}
-    base[:status] = "pending" if pending?
-    base
+    {role: :user, content: content}
   end
 
   # @return [Hash] structured user message with nanosecond timestamp
   def render_verbose
-    base = {role: :user, content: content, timestamp: timestamp}
-    base[:status] = "pending" if pending?
-    base
+    {role: :user, content: content, timestamp: timestamp}
   end
 
   # @return [Hash] verbose output plus token count for debugging
@@ -31,11 +24,4 @@ class UserMessageDecorator < EventDecorator
   def render_brain
     "User: #{truncate_middle(content)}"
   end
-
-  private
-
-  # @return [Boolean] true when this message is queued but not yet sent to LLM
-  def pending?
-    payload["status"] == Event::PENDING_STATUS
-  end
 end

data/app/decorators/web_get_tool_decorator.rb

@@ -19,9 +19,14 @@ require "toon"
 #   decorator.call(body: "<h1>Hi</h1>", content_type: "text/html")
 #   #=> "[Converted: HTML → Markdown]\n\n# Hi"
 class WebGetToolDecorator < ToolDecorator
-  # HTML elements that carry no useful content for an LLM.
-  NOISE_TAGS = %w[script style nav footer aside form noscript iframe
-    svg header menu menuitem].freeze
+  # Tags that never contain readable content — always removed.
+  RENDER_TAGS = %w[script style noscript iframe svg].freeze
+
+  # Structural elements stripped only when no semantic content container is found.
+  STRUCTURAL_TAGS = %w[nav footer aside form header menu menuitem].freeze
+
+  # Semantic HTML5 containers in preference order (first match wins).
+  CONTENT_SELECTORS = ["main", "article", "[role='main']"].freeze
 
   # @param result [Hash] `{body: String, content_type: String}`
   # @return [String] LLM-optimized content with conversion metadata tag
@@ -57,14 +62,19 @@ class WebGetToolDecorator < ToolDecorator
     {text: body, meta: nil}
   end
 
-  # Strips noise elements (scripts, styles, nav, ads) and converts
-  # semantic HTML to Markdown for clean LLM consumption.
+  # Strips noise elements and converts semantic HTML to Markdown.
+  # Warns when the extracted content is suspiciously short.
   #
   # @param body [String] HTML response body
   # @return [Hash] `{text: String, meta: String}`
   def text_html(body)
     markdown = html_to_markdown(body)
-    {text: markdown, meta: "[Converted: HTML → Markdown]"}
+    meta = "[Converted: HTML → Markdown]"
+    char_count = markdown.length
+    if !body.empty? && char_count < Anima::Settings.min_web_content_chars
+      meta += " [Warning: only #{char_count} chars extracted — content may be incomplete]"
+    end
+    {text: markdown, meta: meta}
   end
 
   # Passthrough for unregistered content types.
@@ -80,18 +90,40 @@ class WebGetToolDecorator < ToolDecorator
 
   private
 
-  # Strips noise HTML elements then converts to Markdown.
+  # Converts HTML to Markdown using content-aware extraction.
+  #
+  # Prefers semantic containers (+<main>+, +<article>+, +[role="main"]+)
+  # when available. Falls back to stripping structural noise from the
+  # +<body>+. Rendering artifacts (scripts, styles, iframes, SVGs) are
+  # always removed.
   #
   # @param html [String] raw HTML
   # @return [String] clean Markdown
   def html_to_markdown(html)
     doc = Nokogiri::HTML(html)
-    doc.css(NOISE_TAGS.join(", ")).remove
-    clean_html = doc.at("body")&.inner_html || doc.to_html
+    doc.css(RENDER_TAGS.join(", ")).remove
+
+    clean_html = extract_content(doc)
     markdown = ReverseMarkdown.convert(clean_html, unknown_tags: :bypass, github_flavored: true)
     collapse_whitespace(markdown)
   end
 
+  # Extracts the primary content from a parsed HTML document.
+  #
+  # Prefers semantic containers ({CONTENT_SELECTORS}) and returns the first
+  # match. When none exist, strips {STRUCTURAL_TAGS} from the +<body>+ and
+  # returns what remains.
+  #
+  # @param doc [Nokogiri::HTML::Document]
+  # @return [String] inner HTML of the best content node
+  def extract_content(doc)
+    content = CONTENT_SELECTORS.lazy.filter_map { |sel| doc.at_css(sel) }.first
+    return content.inner_html if content
+
+    doc.css(STRUCTURAL_TAGS.join(", ")).remove
+    doc.at("body")&.inner_html || doc.to_html
+  end
+
   # Collapses excessive blank lines down to a single blank line.
   #
   # @param text [String]

data/app/jobs/agent_request_job.rb

@@ -5,18 +5,18 @@
 #
 # Supports two modes:
 #
-# **Immediate Persist (event_id provided):** The user event was already
+# **Immediate Persist (message_id provided):** The user message was already
 # persisted and broadcast by the caller (e.g. {SessionChannel#speak}).
 # The job verifies LLM delivery — if the first API call fails, the
-# event is deleted and a {Events::BounceBack} is emitted so clients
+# message is deleted and a {Events::BounceBack} is emitted so clients
 # can restore the text to the input field.
 #
-# **Standard (no event_id):** Processes already-persisted events (e.g.
+# **Standard (no message_id):** Processes already-persisted messages (e.g.
 # after pending message promotion). Uses ActiveJob retry/discard for
 # error handling.
 #
-# @example Immediate Persist — event already saved by SessionChannel
-#   AgentRequestJob.perform_later(session.id, event_id: 42)
+# @example Immediate Persist — message already saved by SessionChannel
+#   AgentRequestJob.perform_later(session.id, message_id: 42)
 #
 # @example Standard — pending message processing
 #   AgentRequestJob.perform_later(session.id)
@@ -49,8 +49,8 @@ class AgentRequestJob < ApplicationJob
   end
 
   # @param session_id [Integer] ID of the session to process
-  # @param event_id [Integer, nil] ID of a pre-persisted user event (triggers delivery verification)
-  def perform(session_id, event_id: nil)
+  # @param message_id [Integer, nil] ID of a pre-persisted user message (triggers delivery verification)
+  def perform(session_id, message_id: nil)
     session = Session.find(session_id)
 
     # Atomic: only one job processes a session at a time.
@@ -60,8 +60,8 @@ class AgentRequestJob < ApplicationJob
 
     agent_loop = AgentLoop.new(session: session)
 
-    if event_id
-      deliver_persisted_event(session, event_id, agent_loop)
+    if message_id
+      deliver_persisted_message(session, message_id, agent_loop)
     else
       agent_loop.run
     end
@@ -82,11 +82,11 @@ class AgentRequestJob < ApplicationJob
 
   private
 
-  # Verifies LLM delivery for a pre-persisted user event.
+  # Verifies LLM delivery for a pre-persisted user message.
   #
-  # The event was already created and broadcast by the caller, so
+  # The message was already created and broadcast by the caller, so
   # the user sees their message immediately. This method makes the
-  # first LLM API call — if it fails, the event is deleted and a
+  # first LLM API call — if it fails, the message is deleted and a
   # {Events::BounceBack} notifies clients to remove the phantom
   # message and restore the text to the input field. For
   # {Providers::Anthropic::AuthenticationError}, an additional
@@ -102,26 +102,26 @@ class AgentRequestJob < ApplicationJob
   # execution, subsequent API calls).
   #
   # @param session [Session] the conversation session
-  # @param event_id [Integer] database ID of the pre-persisted user event
+  # @param message_id [Integer] database ID of the pre-persisted user message
   # @param agent_loop [AgentLoop] agent loop instance (reused for continuation)
-  def deliver_persisted_event(session, event_id, agent_loop)
-    event = Event.find_by(id: event_id, session_id: session.id)
-    # Event may have been deleted between SessionChannel#speak and job
+  def deliver_persisted_message(session, message_id, agent_loop)
+    message = Message.find_by(id: message_id, session_id: session.id)
+    # Message may have been deleted between SessionChannel#speak and job
     # execution (e.g. user recalled the message). Exit silently — there
     # is nothing to deliver or bounce back.
-    return unless event
+    return unless message
 
-    content = event.payload["content"]
+    content = message.payload["content"]
 
     begin
       agent_loop.deliver!
     rescue => error
-      event.destroy!
+      message.destroy!
       Events::Bus.emit(Events::BounceBack.new(
         content: content,
         error: error.message,
         session_id: session.id,
-        event_id: event_id
+        message_id: message_id
       ))
       broadcast_auth_required(session.id, error) if error.is_a?(Providers::Anthropic::AuthenticationError)
       return
@@ -155,18 +155,27 @@ class AgentRequestJob < ApplicationJob
 
   # Sets the session's processing flag atomically. Returns true if this
   # job claimed the lock, false if another job already holds it.
-  # Broadcasts the state change to the parent session's HUD.
+  # Broadcasts +session_state: llm_generating+ and the state change to
+  # the parent session's HUD.
   def claim_processing(session_id)
     claimed = Session.where(id: session_id, processing: false).update_all(processing: true) == 1
-    Session.find_by(id: session_id)&.broadcast_children_update_to_parent if claimed
+    if claimed
+      session = Session.find_by(id: session_id)
+      session&.broadcast_session_state("llm_generating")
+      session&.broadcast_children_update_to_parent
+    end
     claimed
   end
 
   # Clears the processing flag so the session can accept new jobs.
-  # Broadcasts the state change to the parent session's HUD.
+  # Broadcasts +session_state: idle+ to the session stream (replaces
+  # the old +processing_stopped+ action) and +children_updated+ to the
+  # parent session's HUD.
   def release_processing(session_id)
     Session.where(id: session_id).update_all(processing: false)
-    Session.find_by(id: session_id)&.broadcast_children_update_to_parent
+    session = Session.find_by(id: session_id)
+    session&.broadcast_session_state("idle")
+    session&.broadcast_children_update_to_parent
   end
 
   # Safety-net clearing of the interrupt flag.

data/app/jobs/count_message_tokens_job.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Counts tokens in a message's payload via the Anthropic API and
+# caches the result on the message record. Enqueued automatically
+# after each LLM message is created.
+class CountMessageTokensJob < ApplicationJob
+  queue_as :default
+
+  retry_on Providers::Anthropic::Error, wait: :polynomially_longer, attempts: 3
+  discard_on ActiveRecord::RecordNotFound
+
+  # @param message_id [Integer] the Message record to count tokens for
+  def perform(message_id)
+    message = Message.find(message_id)
+    return if already_counted?(message)
+
+    provider = Providers::Anthropic.new
+    api_messages = [{role: message.api_role, content: message.payload["content"].to_s}]
+
+    token_count = provider.count_tokens(
+      model: Anima::Settings.model,
+      messages: api_messages
+    )
+
+    # Guard against parallel jobs: reload and re-check before writing.
+    # Uses update! (not update_all) so {Message::Broadcasting} after_update_commit
+    # broadcasts the updated token count to connected clients.
+    message.reload
+    return if already_counted?(message)
+
+    message.update!(token_count: token_count)
+  end
+
+  private
+
+  def already_counted?(message)
+    message.token_count > 0
+  end
+end

data/app/jobs/passive_recall_job.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Runs passive recall after goal updates — searches event history for
+# Runs passive recall after goal updates — searches message history for
 # context relevant to active goals and caches results on the session
 # for viewport injection.
 #
@@ -20,10 +20,10 @@ class PassiveRecallJob < ApplicationJob
     results = Mneme::PassiveRecall.new(session).call
 
     if results.any?
-      session.update_column(:recalled_event_ids, results.map(&:event_id))
+      session.update_column(:recalled_message_ids, results.map(&:message_id))
       Mneme.logger.info("session=#{session_id} — passive recall found #{results.size} memories")
-    elsif session.recalled_event_ids.present?
-      session.update_column(:recalled_event_ids, [])
+    elsif session.recalled_message_ids.present?
+      session.update_column(:recalled_message_ids, [])
     end
   end
 end