anima-core 1.1.3 → 1.3.0

data/lib/tools/remember.rb

@@ -1,23 +1,23 @@
 # frozen_string_literal: true
 
 module Tools
-  # Fractal-resolution zoom into event history. Returns a window centered
-  # on a target event with full detail at the center and compressed context
+  # Fractal-resolution zoom into message history. Returns a window centered
+  # on a target message with full detail at the center and compressed context
   # at the edges — sharp fovea, blurry periphery.
   #
   # Output structure:
   #   [Previous snapshots — compressed context before]
-  #   [Events N-M — full detail, tool_responses compressed to checkmarks]
+  #   [Messages N-M — full detail, tool_responses compressed to checkmarks]
   #   [Following snapshots — compressed context after]
   #
-  # The agent discovers target events via FTS5 search results embedded in
+  # The agent discovers target messages via FTS5 search results embedded in
   # viewport recall snippets. This tool drills down into the full context.
   #
   # @example
-  #   remember(event_id: 42)
+  #   remember(message_id: 42)
   class Remember < Base
-    # Events around the target to include at full resolution.
-    # ±10 events provides sharp foveal detail while keeping output readable.
+    # Messages around the target to include at full resolution.
+    # ±10 messages provides sharp foveal detail while keeping output readable.
     CONTEXT_WINDOW = 20
 
     ROLE_LABELS = {
@@ -28,24 +28,15 @@ module Tools
 
     def self.tool_name = "remember"
 
-    def self.description
-      "Recall the full context around a past event. " \
-        "Returns a fractal-resolution window: high detail at the center " \
-        "(the target event and its neighbors), compressed context at the edges " \
-        "(snapshots before and after). Use this when search results surface " \
-        "a relevant event and you need the surrounding conversation."
-    end
+    def self.description = "Recall the full conversation around a past message."
 
     def self.input_schema
       {
         type: "object",
         properties: {
-          event_id: {
-            type: "integer",
-            description: "The event ID to zoom into (from search results or recall snippets)"
-          }
+          message_id: {type: "integer"}
         },
-        required: ["event_id"]
+        required: ["message_id"]
       }
     end
 
@@ -53,12 +44,12 @@ module Tools
       @session = session
     end
 
-    # @param input [Hash] with "event_id"
-    # @return [String] fractal-resolution window around the target event
+    # @param input [Hash] with "message_id"
+    # @return [String] fractal-resolution window around the target message
     def execute(input)
-      event_id = input["event_id"].to_i
-      target = Event.find_by(id: event_id)
-      return {error: "Event #{event_id} not found"} unless target
+      message_id = input["message_id"].to_i
+      target = Message.find_by(id: message_id)
+      return {error: "Message #{message_id} not found"} unless target
 
       build_fractal_window(target)
     end
@@ -67,17 +58,17 @@ module Tools
 
     # Assembles the three-zone fractal window.
     #
-    # @param target [Event] the center event
+    # @param target [Message] the center message
     # @return [String] formatted fractal window
     def build_fractal_window(target)
       target_session = target.session
-      center_events = fetch_center_events(target, target_session)
-      first_center_id = center_events.first&.id
-      last_center_id = center_events.last&.id
+      center_messages = fetch_center_messages(target, target_session)
+      first_center_id = center_messages.first&.id
+      last_center_id = center_messages.last&.id
 
       sections = build_sections(
         target_session: target_session,
-        center_events: center_events,
+        center_messages: center_messages,
         target_id: target.id,
         first_center_id: first_center_id,
         last_center_id: last_center_id
@@ -86,18 +77,18 @@ module Tools
     end
 
     # Builds ordered sections: header, before snapshots, center, after snapshots.
-    def build_sections(target_session:, center_events:, target_id:, first_center_id:, last_center_id:)
+    def build_sections(target_session:, center_messages:, target_id:, first_center_id:, last_center_id:)
       sections = [session_header(target_session)]
 
       append_snapshot_sections(sections, target_session.snapshots
-        .where("to_event_id < ?", first_center_id)
+        .where("to_message_id < ?", first_center_id)
         .chronological.last(3), label: "PREVIOUS CONTEXT")
 
-      sections << "── FULL CONTEXT (events #{first_center_id}..#{last_center_id}) ──"
-      center_events.each { |event| sections << render_center_event(event, target_id) }
+      sections << "── FULL CONTEXT (messages #{first_center_id}..#{last_center_id}) ──"
+      center_messages.each { |msg| sections << render_center_message(msg, target_id) }
 
       append_snapshot_sections(sections, target_session.snapshots
-        .where("from_event_id > ?", last_center_id)
+        .where("from_message_id > ?", last_center_id)
         .chronological.first(3), label: "FOLLOWING CONTEXT")
 
       sections
@@ -116,12 +107,12 @@ module Tools
       snapshots.each { |snapshot| sections << format_snapshot(snapshot) }
     end
 
-    # Fetches conversation events around the target within a fixed window.
+    # Fetches conversation messages around the target within a fixed window.
     #
-    # @return [Array<Event>] chronologically ordered
-    def fetch_center_events(target, target_session)
+    # @return [Array<Message>] chronologically ordered
+    def fetch_center_messages(target, target_session)
       half = CONTEXT_WINDOW / 2
-      scope = target_session.events.context_events.deliverable
+      scope = target_session.messages.context_messages
       target_id = target.id
 
       before = scope.where("id <= ?", target_id).reorder(id: :desc).limit(half + 1).to_a.reverse
@@ -130,37 +121,37 @@ module Tools
       before + after
     end
 
-    # Renders a center event at full resolution.
-    # Conversation events show full content. Tool calls show name + input.
+    # Renders a center message at full resolution.
+    # Conversation messages show full content. Tool calls show name + input.
     # Tool responses compressed to status indicator.
     #
-    # @param event [Event]
-    # @param target_id [Integer] the event being zoomed into (marked with arrow)
+    # @param message [Message]
+    # @param target_id [Integer] the message being zoomed into (marked with arrow)
     # @return [String]
-    def render_center_event(event, target_id)
-      marker = (event.id == target_id) ? "→" : " "
-      prefix = "#{marker} event #{event.id}"
+    def render_center_message(message, target_id)
+      marker = (message.id == target_id) ? "→" : " "
+      prefix = "#{marker} message #{message.id}"
 
-      "#{prefix} #{format_event_content(event)}"
+      "#{prefix} #{format_message_content(message)}"
     end
 
-    # Formats event content based on type.
-    def format_event_content(event)
-      data = event.payload
+    # Formats message content based on type.
+    def format_message_content(message)
+      data = message.payload
       content = data["content"]
 
-      if ROLE_LABELS.key?(event.event_type)
-        "#{ROLE_LABELS[event.event_type]}: #{content}"
-      elsif event.event_type == "tool_call"
+      if ROLE_LABELS.key?(message.message_type)
+        "#{ROLE_LABELS[message.message_type]}: #{content}"
+      elsif message.message_type == "tool_call"
         format_tool_call(data)
-      elsif event.event_type == "tool_response"
+      elsif message.message_type == "tool_response"
         status = content.to_s.start_with?("Error") ? "error" : "ok"
         "ToolResult: [#{status}] #{data["tool_use_id"]}"
       end
     end
 
     def format_tool_call(data)
-      if data["tool_name"] == Event::THINK_TOOL
+      if data["tool_name"] == Message::THINK_TOOL
         "Think: #{data.dig("tool_input", "thoughts")}"
       else
         "Tool: #{data["tool_name"]}(#{data["tool_input"].to_json.truncate(200)})"
@@ -173,7 +164,7 @@ module Tools
     # @return [String]
     def format_snapshot(snapshot)
       level = (snapshot.level == 2) ? "L2" : "L1"
-      "[#{level} snapshot, events #{snapshot.from_event_id}..#{snapshot.to_event_id}]\n#{snapshot.text}"
+      "[#{level} snapshot, messages #{snapshot.from_message_id}..#{snapshot.to_message_id}]\n#{snapshot.text}"
     end
   end
 end

data/lib/tools/response_truncator.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
+module Tools
+  # Truncates oversized tool results to protect the agent's context window.
+  #
+  # When a tool returns more characters than the configured threshold,
+  # saves the full output to a temp file and returns a truncated version:
+  # first 10 lines + notice + last 10 lines. The agent can use the
+  # +read_file+ tool with offset/limit to inspect the full output.
+  #
+  # Two thresholds exist:
+  # - **Tool threshold** (~3000 chars) — for raw tool output (bash, web, etc.)
+  # - **Sub-agent threshold** (~24000 chars) — for curated sub-agent results
+  #
+  # @example Truncating a tool result
+  #   ResponseTruncator.truncate(huge_string, threshold: 3000)
+  #   # => "line 1\nline 2\n...\n---\n⚠️ Response truncated..."
+  module ResponseTruncator
+    HEAD_LINES = 10
+    TAIL_LINES = 10
+
+    # Attribution prefix for messages routed from sub-agent to parent.
+    # Shared by {Events::Subscribers::SubagentMessageRouter} and
+    # {Tools::MarkGoalCompleted} to keep formatting consistent.
+    ATTRIBUTION_FORMAT = "[sub-agent @%s]: %s"
+
+    NOTICE = <<~NOTICE.strip
+      ---
+      ⚠️ Response truncated (%<total>d lines total%<reason>s). Full output saved to: %<path>s
+      Use `read_file` tool with offset/limit to inspect specific sections.
+      ---
+    NOTICE
+
+    # Truncates content that exceeds the character threshold.
+    #
+    # @param content [Object] the tool result to (maybe) truncate; non-strings pass through unchanged
+    # @param threshold [Integer] character limit before truncation kicks in
+    # @param reason [String, nil] why truncation occurred (e.g. "bash output displays first/last 10 lines")
+    # @return [Object] original value if non-String/under threshold/few lines, truncated String otherwise
+    def self.truncate(content, threshold:, reason: nil)
+      return content unless content.is_a?(String)
+      return content if content.length <= threshold
+
+      lines = content.lines
+      total = lines.size
+      return content if total <= HEAD_LINES + TAIL_LINES
+
+      path = save_full_output(content)
+      head = lines.first(HEAD_LINES).join
+      tail = lines.last(TAIL_LINES).join
+      reason_text = reason ? " — #{reason}" : ""
+      notice = format(NOTICE, total: total, path: path, reason: reason_text)
+
+      "#{head}\n#{notice}\n\n#{tail}"
+    end
+
+    # Saves full content to a temp file that persists until system cleanup.
+    #
+    # @param content [String] the full tool result
+    # @return [String] absolute path to the saved file
+    def self.save_full_output(content)
+      file = Tempfile.create(["tool_result_", ".txt"])
+      file.write(content)
+      file.close
+      file.path
+    end
+  end
+end

data/lib/tools/spawn_specialist.rb

@@ -21,10 +21,9 @@ module Tools
 
     # Builds description dynamically to include available specialists.
     def self.description
-      base = "Spawn a named specialist sub-agent to work on a task autonomously. " \
-        "The specialist has a predefined role, system prompt, and tool set. " \
-        "Its text messages are forwarded to you automatically. " \
-        "Address it via @name to send follow-up instructions."
+      base = "Need a specific skill set for the job? Bring in a specialist. " \
+        "Its messages appear in yours; any message containing " \
+        "@nickname is forwarded — even casual mentions will wake it."
 
       registry = Agents::Registry.instance
       return base unless registry.any?
@@ -39,16 +38,9 @@ module Tools
         type: "object",
         properties: {
           name: name_property,
-          task: {
-            type: "string",
-            description: "What the specialist should do (persisted as its first user message)"
-          },
-          expected_output: {
-            type: "string",
-            description: "Description of the expected deliverable"
-          }
+          task: {type: "string", description: "State the goal — the specialist knows its method."}
         },
-        required: %w[name task expected_output]
+        required: %w[name task]
       }
     end
 
@@ -57,7 +49,7 @@ module Tools
       registry = Agents::Registry.instance
       prop = {
         type: "string",
-        description: "Named specialist agent to spawn from the registry."
+        description: "Specialist to spawn."
       }
       prop[:enum] = registry.names if registry.any?
       prop
@@ -76,46 +68,44 @@ module Tools
     # persists the task as a user message, and queues background processing.
     # Returns immediately (non-blocking).
     #
-    # @param input [Hash<String, Object>] with "name", "task", and "expected_output"
+    # @param input [Hash<String, Object>] with "name" and "task"
     # @return [String] confirmation with child session ID
     # @return [Hash{Symbol => String}] with :error key on validation failure
     def execute(input)
       task = input["task"].to_s.strip
-      expected_output = input["expected_output"].to_s.strip
       name = input["name"].to_s.strip
 
       return {error: "Name cannot be blank"} if name.empty?
       return {error: "Task cannot be blank"} if task.empty?
-      return {error: "Expected output cannot be blank"} if expected_output.empty?
 
       definition = @agent_registry.get(name)
       return {error: "Unknown agent: #{name}"} unless definition
 
-      child = spawn_child(definition, task, expected_output)
+      child = spawn_child(definition, task)
       nickname = child.name
       "Specialist @#{nickname} spawned (session #{child.id}). " \
         "Its messages will appear in your conversation. " \
-        "Reply with @#{nickname} to send it instructions."
+        "Reply with @#{nickname} to send it instructions — " \
+        "any message mentioning @#{nickname} is forwarded, even in narration."
     end
 
     private
 
-    def spawn_child(definition, task, expected_output)
-      prompt = build_prompt(definition, expected_output)
+    def spawn_child(definition, task)
       child = Session.create!(
         parent_session_id: @session.id,
-        prompt: prompt,
+        prompt: build_prompt(definition),
         granted_tools: definition.tools
       )
-      child.create_user_event(task)
+      pin_goal_and_frame(child, task)
       assign_nickname_via_brain(child)
       child.broadcast_children_update_to_parent
       AgentRequestJob.perform_later(child.id)
       child
     end
 
-    def build_prompt(definition, expected_output)
-      "#{definition.prompt}\n\n#{COMMUNICATION_INSTRUCTION}\n\n#{EXPECTED_DELIVERABLE_PREFIX}#{expected_output}"
+    def build_prompt(definition)
+      "#{definition.prompt}\n\n#{COMMUNICATION_INSTRUCTION}"
     end
   end
 end

data/lib/tools/spawn_subagent.rb

@@ -14,29 +14,22 @@ module Tools
   class SpawnSubagent < Base
     include SubagentPrompts
 
-    GENERIC_PROMPT = "You are a focused sub-agent. #{COMMUNICATION_INSTRUCTION}\n"
+    GENERIC_PROMPT = "#{COMMUNICATION_INSTRUCTION}\n"
 
     def self.tool_name = "spawn_subagent"
 
     def self.description
-      "Spawn a generic sub-agent to work on a task autonomously. " \
-        "The sub-agent inherits your conversation context, works independently, " \
-        "and its text messages are forwarded to you automatically. " \
-        "Address it via @nickname to send follow-up instructions."
+      "Task feels like a sidequest or a context-switch? Hand it off. " \
+        "Inherits your context; its messages appear in yours. " \
+        "Any message containing @nickname is forwarded — " \
+        "even casual mentions will wake the sub-agent."
     end
 
     def self.input_schema
       {
         type: "object",
         properties: {
-          task: {
-            type: "string",
-            description: "What the sub-agent should do (persisted as its first user message)"
-          },
-          expected_output: {
-            type: "string",
-            description: "Description of the expected deliverable"
-          },
+          task: {type: "string"},
           tools: {
             type: "array",
             items: {type: "string"},
@@ -45,7 +38,7 @@ module Tools
               "Valid tools: #{AgentLoop::STANDARD_TOOLS_BY_NAME.keys.join(", ")}"
           }
         },
-        required: %w[task expected_output]
+        required: %w[task]
       }
     end
 
@@ -58,37 +51,36 @@ module Tools
     # persists the task as a user message, and queues background processing.
     # Returns immediately after brain completes (blocking for ~200ms).
     #
-    # @param input [Hash<String, Object>] with "task", "expected_output", and optional "tools"
+    # @param input [Hash<String, Object>] with "task" and optional "tools"
     # @return [String] confirmation with child session ID and @nickname
     # @return [Hash{Symbol => String}] with :error key on validation failure
     def execute(input)
       task = input["task"].to_s.strip
-      expected_output = input["expected_output"].to_s.strip
 
       return {error: "Task cannot be blank"} if task.empty?
-      return {error: "Expected output cannot be blank"} if expected_output.empty?
 
       tools = normalize_tools(input["tools"])
 
       error = validate_tools(tools)
       return error if error
 
-      child = spawn_child(task, expected_output, tools)
+      child = spawn_child(task, tools)
       nickname = child.name
       "Sub-agent @#{nickname} spawned (session #{child.id}). " \
         "Its messages will appear in your conversation. " \
-        "Reply with @#{nickname} to send it instructions."
+        "Reply with @#{nickname} to send it instructions — " \
+        "any message mentioning @#{nickname} is forwarded, even in narration."
     end
 
     private
 
-    def spawn_child(task, expected_output, granted_tools)
+    def spawn_child(task, granted_tools)
       child = Session.create!(
         parent_session_id: @session.id,
-        prompt: "#{GENERIC_PROMPT}\n#{EXPECTED_DELIVERABLE_PREFIX}#{expected_output}",
+        prompt: GENERIC_PROMPT,
         granted_tools: granted_tools
       )
-      child.create_user_event(task)
+      pin_goal_and_frame(child, task)
       assign_nickname_via_brain(child)
       child.broadcast_children_update_to_parent
       AgentRequestJob.perform_later(child.id)

data/lib/tools/subagent_prompts.rb

@@ -1,25 +1,61 @@
 # frozen_string_literal: true
 
 module Tools
-  # Shared prompt fragments and nickname logic for tools that spawn sub-agent sessions.
+  # Shared prompt fragments and spawn logic for tools that create sub-agent sessions.
   # Included by {SpawnSubagent} and {SpawnSpecialist} to avoid duplication.
   module SubagentPrompts
-    COMMUNICATION_INSTRUCTION = "Your text messages are automatically forwarded to the parent agent. " \
-      "When you finish, write your final summary and stop — no special tool needed. " \
-      "If you need clarification, just ask — the parent can reply."
+    # Prepended to every sub-agent's stored prompt after nickname assignment.
+    # Establishes identity before any other instruction.
+    IDENTITY_TEMPLATE = "You are @%s, a sub-agent of the primary agent."
 
-    EXPECTED_DELIVERABLE_PREFIX = "Expected deliverable: "
+    COMMUNICATION_INSTRUCTION = "Your messages reach the parent automatically. " \
+      "Ask if you need clarification — the parent can reply."
+
+    # Framing message inserted as the sub-agent's first user message.
+    # This is the "brake" between inherited parent context and the sub-agent's
+    # own task — without it, the model continues the parent's trajectory.
+    FORK_FRAMING_MESSAGE = "You were spawned to help with a single task. " \
+      "The messages above are the parent agent's context — background for your work, " \
+      "but the parent's goals are not yours. " \
+      "Your sole task is described in your Goal."
 
     private
 
-    # Runs the analytical brain synchronously to assign a nickname.
+    # Creates the sub-agent's Goal from the task description and inserts
+    # the framing message as the first user message.
+    #
+    # @param child [Session] the newly created child session
+    # @param task [String] the task description to pin as the sole Goal
+    # @return [void]
+    def pin_goal_and_frame(child, task)
+      child.goals.create!(description: task)
+      child.create_user_message(FORK_FRAMING_MESSAGE)
+    end
+
+    # Runs the analytical brain synchronously to assign a nickname,
+    # then prepends identity context to the stored prompt.
     # Falls back to a sequential "agent-N" name on any failure.
+    # Identity injection runs in +ensure+ so it applies to both
+    # brain-assigned and fallback nicknames.
     def assign_nickname_via_brain(child)
       AnalyticalBrain::Runner.new(child).call
       child.reload
     rescue => error
       Rails.logger.warn("Sub-agent nickname assignment failed: #{error.message}")
       child.update!(name: fallback_nickname)
+    ensure
+      inject_identity_context(child)
+    end
+
+    # Prepends identity context (nickname + sub-agent status) to the child's
+    # stored prompt. Called after nickname assignment so the sub-agent knows
+    # who it is from first token.
+    #
+    # @param child [Session] the child session with a nickname already set
+    # @return [void]
+    def inject_identity_context(child)
+      identity = format(IDENTITY_TEMPLATE, child.name)
+      child.update!(prompt: "#{identity}\n#{child.prompt}")
     end
 
     def fallback_nickname

data/lib/tools/think.rb

@@ -13,6 +13,10 @@ module Tools
   # - **inner** (default) — silent reasoning, visible only in verbose/debug
   # - **aloud** — narration shown in all view modes with a thought bubble
   #
+  # The +maxLength+ on thoughts is controlled by +thinking_budget+ in settings.
+  # Sub-agents receive half the main agent's budget — their tasks are scoped
+  # and less complex, so runaway reasoning is a stronger signal of confusion.
+  #
   # @example Silent planning between tool calls
   #   think(thoughts: "Three auth failures — likely a config issue, not individual tests.")
   #
@@ -21,30 +25,42 @@ module Tools
   class Think < Base
     def self.tool_name = "think"
 
-    def self.description
-      "Express your internal reasoning between tool calls. " \
-        "Use this to analyze intermediate results, plan next steps, or make decisions before continuing. " \
-        "Set visibility to \"aloud\" when you want the user to see your thought process."
-    end
+    def self.description = "Think out loud or silently."
 
+    # Schema is static — maxLength is injected at runtime by the registry
+    # via {#dynamic_schema} when session context is available.
     def self.input_schema
       {
         type: "object",
         properties: {
-          thoughts: {
-            type: "string",
-            description: "Your reasoning, analysis, or internal monologue"
-          },
+          thoughts: {type: "string"},
           visibility: {
             type: "string",
             enum: ["inner", "aloud"],
-            description: "\"inner\" (default) for silent reasoning; \"aloud\" to narrate for the user"
+            description: "inner (default) is silent. aloud is shown to the user."
           }
         },
         required: ["thoughts"]
       }
     end
 
+    # @param session [Session, nil] current session for budget calculation
+    def initialize(session: nil, **)
+      @session = session
+    end
+
+    # Returns the tool schema with a thinking budget applied as maxLength
+    # on the thoughts property. Sub-agents get half the budget.
+    #
+    # @return [Hash] Anthropic tool schema with maxLength constraint
+    def dynamic_schema
+      schema = self.class.schema.deep_dup
+      budget = Anima::Settings.thinking_budget
+      budget /= 2 if @session&.sub_agent?
+      schema[:input_schema][:properties][:thoughts][:maxLength] = budget
+      schema
+    end
+
     # @param input [Hash] with "thoughts" and optional "visibility"
     # @return [String] acknowledgement — the value is in the call, not the result
     def execute(input)

data/lib/tools/web_get.rb

@@ -15,13 +15,13 @@ module Tools
   class WebGet < Base
     def self.tool_name = "web_get"
 
-    def self.description = "Fetch content from a URL via HTTP GET and return the response body"
+    def self.description = "Fetch a URL."
 
     def self.input_schema
       {
         type: "object",
         properties: {
-          url: {type: "string", description: "The URL to fetch (http or https)"}
+          url: {type: "string"}
         },
         required: ["url"]
       }
@@ -47,10 +47,11 @@ module Tools
       end
 
       response = HTTParty.get(url, timeout: timeout, follow_redirects: false, ssl_ca_file: Certifi.where)
-      body = truncate_body(response.body.to_s)
       content_type = response.content_type || "text/plain"
+      body = response.body.to_s
+      body = strip_html_noise(body) if content_type.include?("text/html")
 
-      {body: body, content_type: content_type}
+      {body: truncate_body(body), content_type: content_type}
     rescue URI::InvalidURIError => error
       {error: "Invalid URL: #{error.message}"}
     rescue Net::OpenTimeout, Net::ReadTimeout
@@ -68,5 +69,23 @@ module Tools
       body.byteslice(0, max_bytes).scrub +
         "\n\n[Truncated: response exceeded #{max_bytes} bytes]"
     end
+
+    # First-stage noise stripping — runs before truncation so that the
+    # byte budget is spent on content, not on scripts/SVGs/metadata.
+    # Each pattern targets one tag type for easy maintenance.
+    # The decorator applies a second, structure-aware pass via Nokogiri.
+    HTML_NOISE_PATTERNS = [
+      %r{<head\b[^>]*>.*?</head>}mi,       # metadata, link/meta tags
+      %r{<script\b[^>]*>.*?</script>}mi,   # JavaScript
+      %r{<style\b[^>]*>.*?</style>}mi,      # CSS
+      %r{<svg\b[^>]*>.*?</svg>}mi,          # inline graphics
+      %r{<template\b[^>]*>.*?</template>}mi, # deferred markup
+      %r{<noscript\b[^>]*>.*?</noscript>}mi  # JS-disabled fallbacks
+    ].freeze
+    private_constant :HTML_NOISE_PATTERNS
+
+    def strip_html_noise(html)
+      HTML_NOISE_PATTERNS.reduce(html) { |text, pattern| text.gsub(pattern, "") }
+    end
   end
 end