aia 2.0.0.0.pre.alpha → 2.0.0.0.pre.beta2

data/lib/aia/mention_router.rb

@@ -10,6 +10,7 @@ module AIA
   class MentionRouter
     include ContentExtractor
     include HandlerProtocol
+    include Speech
 
     # Reserved @mention that broadcasts the message to every crew member.
     BROADCAST_TOKEN = 'crew'
@@ -25,6 +26,7 @@ module AIA
     #
     # @param context [HandlerContext] — reads context.robot and context.prompt
     # @return [Boolean]
+    # :reek:TooManyStatements -- mention routing: scan, resolve, report unknowns, dispatch; one decision chain
     def handle(context) # rubocop:disable Naming/PredicateMethod
       robot  = context.robot
       prompt = context.prompt
@@ -120,10 +122,11 @@ module AIA
 
     # A single addressed robot streams its reply token-by-token.
     def run_streamed(bot, prompt)
+      name = bot.name
       result, streamed_content, elapsed = @streaming_runner.run(
         bot, prompt,
-        header: "\nAI (#{bot.name}):\n   ",
-        spinner_message: "#{bot.name} processing..."
+        header: "\nAI (#{name}):\n   ",
+        spinner_message: "#{name} processing..."
       )
       content = streamed_content || extract_content(result)
 
@@ -137,7 +140,7 @@ module AIA
       finalize_reply(bot, prompt, result, content, elapsed)
       content
     rescue StandardError => e
-      @ui_presenter.display_info("Error from #{bot.name}: #{e.class}: #{e.message}")
+      @ui_presenter.display_info("Error from #{name}: #{e.class}: #{e.message}")
       nil
     end
 
@@ -156,6 +159,7 @@ module AIA
 
     # Run one crew member to completion (off the streaming path), in a worker
     # thread. Returns [bot, result, elapsed, error] — no shared state touched.
+    # :reek:DuplicateMethodCall -- each clock_gettime must read the clock at that moment (start, success end, failure end)
     def run_member(bot, prompt)
       started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       result  = bot.run(prompt, mcp: :inherit, tools: :inherit)
@@ -209,52 +213,5 @@ module AIA
       return message.model    if message.respond_to?(:model)    && message.model
       nil
     end
-
-    def speak(content)
-      return unless AIA.speak?
-
-      audio   = AIA.config.audio
-      command = audio.speak_command || 'say'
-      env     = {}
-      env['SPEECH_MODEL'] = audio.speech_model if audio.speech_model
-
-      if command == 'say'
-        run_with_spinner("Speaking...") do
-          if audio.voice && !audio.voice.to_s.strip.empty?
-            system(env, command, '-v', audio.voice, content.to_s)
-          else
-            system(env, command, content.to_s)
-          end
-        end
-      else
-        require 'tempfile'
-        tmpfile = Tempfile.new(['aia-tts-', '.mp3'])
-        tmpfile.close
-        begin
-          run_with_spinner("Converting to audio...") do
-            system(env, command, content.to_s, tmpfile.path)
-          end
-          if File.size?(tmpfile.path)
-            run_with_spinner("Speaking...") do
-              system('afplay', tmpfile.path)
-            end
-          end
-        ensure
-          tmpfile.unlink
-        end
-      end
-    rescue StandardError => e
-      $stderr.puts "Warning: Speech failed: #{e.message}"
-    end
-
-    def run_with_spinner(message)
-      spinner = TTY::Spinner.new("[:spinner] #{message}", format: :bouncing_ball, output: $stderr)
-      spinner.auto_spin
-      begin
-        yield
-      ensure
-        spinner.stop
-      end
-    end
   end
 end

data/lib/aia/network_builder.rb

@@ -15,6 +15,7 @@ module AIA
     # @param config [AIA::Config]
     # @param namer [RobotNamer]
     # @return [RobotLab::Network]
+    # :reek:TooManyStatements -- gathers shared robot inputs then declares one network task per pipeline step
     def build_pipeline_network(config, namer)
       prompts = config.pipeline
       run_config = RobotFactory.build_run_config(config)
@@ -66,13 +67,15 @@ module AIA
     # @param config [AIA::Config]
     # @param namer [RobotNamer]
     # @return [RobotLab::Network]
+    # :reek:TooManyStatements -- gathers shared robot inputs, declares one task per roster member plus the synthesizer
     def build_consensus_network(config, namer)
       run_config = RobotFactory.build_run_config(config)
-      tools = ToolLoader.filtered_tools(config)
-      mcp = RobotFactory.mcp_server_configs(config)
-      primary = config.models.first
+      tools  = ToolLoader.filtered_tools(config)
+      mcp    = RobotFactory.mcp_server_configs(config)
+      models = config.models
+      primary = models.first
       aia_config = config
-      roster = config.models.map { |spec| { name: namer.name_for(spec.name), spec: spec } }
+      roster = models.map { |spec| { name: namer.name_for(spec.name), spec: spec } }
       build_robot = ->(entry) { build_roster_robot(entry, roster, tools, mcp, run_config, aia_config) }
 
       RobotLab.create_network(name: "aia-consensus") do
@@ -89,11 +92,12 @@ module AIA
           config:        run_config
         )
         task :consensus, synthesizer,
-             depends_on: config.models.map { |s| s.internal_id.to_sym }
+             depends_on: models.map { |s| s.internal_id.to_sym }
       end
     end
 
     # Shared helper: builds a single roster robot (used by parallel and consensus networks).
+    # :reek:LongParameterList { max_params: 6 } -- pass-through of the shared per-network build inputs
     def build_roster_robot(entry, roster, tools, mcp, run_config, aia_config)
       spec = entry[:spec]
       identity = SystemPromptAssembler.build_identity_prompt(entry[:name], spec, roster)
@@ -116,6 +120,7 @@ module AIA
     # @param namer [RobotNamer]
     # @param server_groups [Array<Array<Hash>>]
     # @return [RobotLab::Network]
+    # :reek:TooManyStatements -- gathers shared robot inputs, declares one task per server group plus the synthesizer
     def build_concurrent_mcp_network(config, namer, server_groups)
       run_config = RobotFactory.build_run_config(config)
       tools = ToolLoader.filtered_tools(config)

data/lib/aia/network_memory_manager.rb

@@ -16,12 +16,12 @@ module AIA
       def initialize_memory(network, config)
         return network unless network.respond_to?(:memory)
 
-        memory = network.memory
-        memory.data.session_id  = SecureRandom.hex(8)
-        memory.data.model_count = config.models.size
-        memory.data.model_names = config.models.map(&:name)
-        memory.data.mode        = config.flags.consensus ? :consensus : :parallel
-        memory.data.turn_count  = 0
+        data = network.memory.data
+        data.session_id  = SecureRandom.hex(8)
+        data.model_count = config.models.size
+        data.model_names = config.models.map(&:name)
+        data.mode        = config.flags.consensus ? :consensus : :parallel
+        data.turn_count  = 0
 
         network
       end

data/lib/aia/pipeline_orchestrator.rb

@@ -25,6 +25,8 @@ module AIA
     # Process all prompts in the pipeline.
     #
     # @param config [AIA::Config]
+    # :reek:TooManyStatements -- shift-based loop so front-matter pipeline edits take effect; tracking interleaved
+    # :reek:DuplicateMethodCall -- config.pipeline is deliberately re-read each iteration because prompt front matter mutates it mid-loop
     def process(config)
       bridge   = TrakFlowBridge.new
       tracking = bridge.available? && config.flags.track_pipeline
@@ -82,11 +84,14 @@ module AIA
       end
     end
 
+    # :reek:TooManyStatements -- image request assembly, spinner-wrapped generation, then save/display of the result
     def generate_image(prompt_text, config)
       img_cfg = config.image
+      quality = img_cfg.quality
+      style   = img_cfg.style
       params  = {}
-      params[:quality] = img_cfg.quality if img_cfg.quality && !img_cfg.quality.to_s.strip.empty?
-      params[:style]   = img_cfg.style   if img_cfg.style   && !img_cfg.style.to_s.strip.empty?
+      params[:quality] = quality if quality && !quality.to_s.strip.empty?
+      params[:style]   = style   if style   && !style.to_s.strip.empty?
 
       image = @ui.with_spinner("Generating image") do
         RubyLLM.paint(
@@ -124,14 +129,16 @@ module AIA
     end
 
     # Check if concurrent MCP mode should be used
+    # :reek:TooManyStatements -- ordered eligibility gates (server count, auto/forced, discovery, grouping threshold) before the build
     def maybe_use_concurrent_mcp(prompt_text, config)
       return nil unless (config.mcp_servers || []).size > 1
 
+      turn_state  = AIA.turn_state
       concurrency = config.respond_to?(:concurrency) ? config.concurrency : nil
-      return nil unless concurrency&.auto || AIA.turn_state.force_concurrent_mcp
+      return nil unless concurrency&.auto || turn_state.force_concurrent_mcp
 
-      if AIA.turn_state.force_concurrent_mcp
-        AIA.turn_state.force_concurrent_mcp = false
+      if turn_state.force_concurrent_mcp
+        turn_state.force_concurrent_mcp = false
       end
 
       discovery         = MCPDiscovery.new
@@ -151,13 +158,15 @@ module AIA
     end
 
     # Build prompt text from a prompt_id
+    # :reek:TooManyStatements -- layered prompt assembly: parameters, role prefix, skills, stdin, context files, in a fixed order
     def build_prompt_text(prompt_id, config)
       parsed = @prompt_handler.fetch_prompt(prompt_id)
       return nil unless parsed
 
-      if parsed.respond_to?(:parameters) && parsed.parameters && !parsed.parameters.empty?
-        values = @input_collector.collect(parsed.parameters)
-        values.each { |k, v| parsed.parameters[k] = v }
+      parameters = parsed.respond_to?(:parameters) ? parsed.parameters : nil
+      if parameters && !parameters.empty?
+        values = @input_collector.collect(parameters)
+        values.each { |k, v| parameters[k] = v }
       end
 
       prompt_text = parsed.to_s
@@ -180,8 +189,9 @@ module AIA
         prompt_text = "#{prompt_text}\n\n#{skill_content}" if skill_content
       end
 
-      if config.stdin_content && !config.stdin_content.strip.empty?
-        prompt_text = "#{prompt_text}\n\n#{config.stdin_content}"
+      stdin_content = config.stdin_content
+      if stdin_content && !stdin_content.strip.empty?
+        prompt_text = "#{prompt_text}\n\n#{stdin_content}"
         config.stdin_content = nil
       end
 

data/lib/aia/plugin_monitor.rb

@@ -13,6 +13,7 @@ module AIA
   # CPU). If `listen` cannot be loaded, it falls back to a background thread that
   # polls file signatures ([mtime, size]). Either way the same #react logic drives
   # {PluginLoader}, so behavior is identical — only latency differs.
+  # :reek:TooManyInstanceVariables -- holds both backends' state (listener vs polling thread) plus watch config and callbacks
   class PluginMonitor
     DEFAULT_INTERVAL = 1.0 # seconds (polling fallback only)
 
@@ -83,9 +84,11 @@ module AIA
     #
     # @return [Array<Array(Symbol, String)>] e.g. [[:added, "/p/foo.rb"], ...]
     def detect_changes(old_snapshot, new_snapshot)
-      added   = (new_snapshot.keys - old_snapshot.keys).map { |path| [:added, path] }
-      removed = (old_snapshot.keys - new_snapshot.keys).map { |path| [:removed, path] }
-      modified = (old_snapshot.keys & new_snapshot.keys)
+      old_keys = old_snapshot.keys
+      new_keys = new_snapshot.keys
+      added   = (new_keys - old_keys).map { |path| [:added, path] }
+      removed = (old_keys - new_keys).map { |path| [:removed, path] }
+      modified = (old_keys & new_keys)
                  .reject { |path| new_snapshot[path] == old_snapshot[path] }
                  .map { |path| [:modified, path] }
       added + removed + modified
@@ -115,9 +118,9 @@ module AIA
     # Map a listen callback into per-file reactions, ignoring anything that is
     # not a top-level file of the plugins directory (listen watches recursively).
     def handle_listen_events(modified, added, removed)
-      Array(added).each    { |path| react(:added, path)    if top_level?(path) }
-      Array(modified).each { |path| react(:modified, path) if top_level?(path) }
-      Array(removed).each  { |path| react(:removed, path)  if top_level?(path) }
+      { added: added, modified: modified, removed: removed }.each do |event, paths|
+        Array(paths).each { |path| react(event, path) if top_level?(path) }
+      end
     end
 
     # listen reports resolved (symlink-free) paths, and on macOS the plugins

data/lib/aia/prompt_decomposer.rb

@@ -75,7 +75,9 @@ module AIA
     #
     # @param prompt [String] the user's prompt
     # @return [Array<String>] sub-task descriptions (empty if not decomposable)
+    # :reek:TooManyStatements -- schema vs JSON-fallback probe setup, run, extraction, and rescue reporting in one flow
     def decompose(prompt)
+      logger     = AIA.logger
       probe      = build_probe_robot
       use_schema = structured_output?
 
@@ -83,17 +85,17 @@ module AIA
         probe.with_schema(SUBTASKS_SCHEMA)
         full_prompt = DECOMPOSITION_PROMPT % { prompt: prompt }
       else
-        AIA.logger.warn("PromptDecomposer: configured model does not support structured output — using JSON prompt fallback")
+        logger.warn("PromptDecomposer: configured model does not support structured output — using JSON prompt fallback")
         full_prompt = (DECOMPOSITION_PROMPT + FALLBACK_JSON_INSTRUCTION) % { prompt: prompt }
       end
 
       result   = probe.run(full_prompt, mcp: :none, tools: :none)
       content  = extract_content(result)
-      AIA.logger.debug("PromptDecomposer#decompose content class=#{content.class}")
+      logger.debug("PromptDecomposer#decompose content class=#{content.class}")
       subtasks = extract_subtasks(content)
       subtasks.is_a?(Array) ? subtasks.select { |t| t.is_a?(String) && !t.empty? } : []
     rescue StandardError => e
-      AIA.logger.warn("PromptDecomposer#decompose failed: #{e.class}: #{e.message}")
+      logger.warn("PromptDecomposer#decompose failed: #{e.class}: #{e.message}")
       []
     end
 

data/lib/aia/prompt_handler.rb

@@ -4,6 +4,7 @@ require 'pm'
 require 'erb'
 
 module AIA
+  # :reek:TooManyMethods -- prompt/role fetching, front-matter merging, and fzf search form one lookup pipeline of small named steps
   class PromptHandler
     include AIA::SkillUtils
 
@@ -65,11 +66,12 @@ module AIA
       return handle_missing_role("roles/") if role_id.nil?
       return fetch_role_from_path(role_id) if path_based_id?(role_id)
 
-      unless role_id.start_with?(AIA.config.prompts.roles_prefix)
-        role_id = "#{AIA.config.prompts.roles_prefix}/#{role_id}"
+      prompts_cfg = AIA.config.prompts
+      unless role_id.start_with?(prompts_cfg.roles_prefix)
+        role_id = "#{prompts_cfg.roles_prefix}/#{role_id}"
       end
 
-      role_file_path = File.join(@prompts_dir, "#{role_id}#{AIA.config.prompts.extname}")
+      role_file_path = File.join(@prompts_dir, "#{role_id}#{prompts_cfg.extname}")
 
       parsed = if File.exist?(role_file_path)
                  # PM.parse(role_id) cannot resolve subdirectory IDs like "roles/jersey_mike"
@@ -171,56 +173,47 @@ module AIA
     end
 
     # Apply root-level shorthand keys to AIA.config
-    # rubocop:disable Metrics/AbcSize
+    # :reek:TooManyStatements -- one guarded assignment per supported front-matter shorthand key
     def apply_root_shorthands(meta_hash)
-      # model → AIA.config.models (replace with single-model array)
-      model_val = meta_hash['model'] || meta_hash[:model]
-      if model_val
-        AIA.config.models = [model_val]
-      end
+      cfg = AIA.config
 
-      # temperature → AIA.config.llm.temperature
-      temp_val = meta_hash['temperature'] || meta_hash[:temperature]
-      if temp_val
-        AIA.config.llm.temperature = temp_val
-      end
+      # model → cfg.models (replace with single-model array)
+      model_val = shorthand(meta_hash, :model)
+      cfg.models = [model_val] if model_val
 
-      # top_p → AIA.config.llm.top_p
-      top_p_val = meta_hash['top_p'] || meta_hash[:top_p]
-      if top_p_val
-        AIA.config.llm.top_p = top_p_val
-      end
+      temp_val = shorthand(meta_hash, :temperature)
+      cfg.llm.temperature = temp_val if temp_val
 
-      # next → AIA.config.pipeline (replace)
-      next_val = meta_hash['next'] || meta_hash[:next]
-      if next_val
-        if AIA.config.pipeline.any?
-          logger.info "Prompt metadata 'next: #{next_val}' overrides remaining pipeline #{AIA.config.pipeline.inspect}"
-        end
-        AIA.config.pipeline = [next_val]
-      end
+      top_p_val = shorthand(meta_hash, :top_p)
+      cfg.llm.top_p = top_p_val if top_p_val
 
-      # pipeline → AIA.config.pipeline (replace)
-      pipeline_val = meta_hash['pipeline'] || meta_hash[:pipeline]
-      if pipeline_val
-        if AIA.config.pipeline.any?
-          logger.info "Prompt metadata 'pipeline' overrides remaining pipeline #{AIA.config.pipeline.inspect}"
-        end
-        AIA.config.pipeline = Array(pipeline_val)
-      end
+      # next / pipeline → cfg.pipeline (replace)
+      next_val = shorthand(meta_hash, :next)
+      apply_pipeline_shorthand(cfg, [next_val], "next: #{next_val}") if next_val
 
-      # shell → AIA.config.flags.shell (and PM's shell via metadata)
-      shell_val = meta_hash['shell'] || meta_hash[:shell]
-      unless shell_val.nil?
-        AIA.config.flags.shell = shell_val
-      end
+      pipeline_val = shorthand(meta_hash, :pipeline)
+      apply_pipeline_shorthand(cfg, Array(pipeline_val), "pipeline") if pipeline_val
+
+      # shell / erb → cfg.flags (and PM's shell/erb via metadata)
+      shell_val = shorthand(meta_hash, :shell)
+      cfg.flags.shell = shell_val unless shell_val.nil?
+
+      erb_val = shorthand(meta_hash, :erb)
+      cfg.flags.erb = erb_val unless erb_val.nil?
+    end
 
-      # erb → AIA.config.flags.erb (and PM's erb via metadata)
-      erb_val = meta_hash['erb'] || meta_hash[:erb]
-      return if erb_val.nil?
-      AIA.config.flags.erb = erb_val
+    # Fetch a front-matter shorthand value by string or symbol key.
+    def shorthand(meta_hash, key)
+      meta_hash[key.to_s] || meta_hash[key]
+    end
+
+    # Replace cfg.pipeline, logging when a remaining pipeline is overridden.
+    def apply_pipeline_shorthand(cfg, new_pipeline, label)
+      if cfg.pipeline.any?
+        logger.info "Prompt metadata '#{label}' overrides remaining pipeline #{cfg.pipeline.inspect}"
+      end
+      cfg.pipeline = new_pipeline
     end
-    # rubocop:enable Metrics/AbcSize
 
     def logger
       @logger ||= LoggerManager.aia_logger
@@ -353,8 +346,9 @@ module AIA
     end
 
     def search_role_id_with_fzf(initial_query)
-      role_files = Dir.glob(File.join(@roles_dir, "*#{AIA.config.prompts.extname}"))
-                      .map { |file| File.basename(file, AIA.config.prompts.extname) }
+      prompts_cfg = AIA.config.prompts
+      role_files = Dir.glob(File.join(@roles_dir, "*#{prompts_cfg.extname}"))
+                      .map { |file| File.basename(file, prompts_cfg.extname) }
       fzf = AIA::Fzf.new(
         list: role_files,
         directory: @prompts_dir,
@@ -369,8 +363,8 @@ module AIA
         raise "No role ID selected"
       end
 
-      unless role.start_with?(AIA.config.prompts.roles_prefix)
-        role = AIA.config.prompts.roles_prefix + '/' + role
+      unless role.start_with?(prompts_cfg.roles_prefix)
+        role = prompts_cfg.roles_prefix + '/' + role
       end
 
       role

data/lib/aia/robot_factory.rb

@@ -14,6 +14,7 @@ require_relative 'network_builder'
 require_relative 'history_transfer'
 
 module AIA
+  # :reek:TooManyMethods -- factory facade: every robot/network build variant plus its run-config helpers lives behind one entry point
   class RobotFactory
     # The max_tokens default from defaults.yml — optimised for cloud APIs that treat
     # it as an output-only cap. Local providers (Ollama, LM Studio) bound input+output
@@ -114,9 +115,10 @@ module AIA
 
       # Reuse the build-time tool cache when present, else load tools fresh.
       def apply_tool_cache(config)
-        if ToolLoader.cached_tools
-          config.loaded_tools = ToolLoader.cached_tools
-          config.tool_names = ToolLoader.cached_tools.map { |t| t.respond_to?(:name) ? t.name : t.class.name }.join(', ')
+        cached = ToolLoader.cached_tools
+        if cached
+          config.loaded_tools = cached
+          config.tool_names = cached.map { |t| t.respond_to?(:name) ? t.name : t.class.name }.join(', ')
         else
           ToolLoader.load_tools(config)
         end
@@ -141,14 +143,16 @@ module AIA
       # - max_tokens remains a RobotLab::RunConfig field; AIA normalizes it at
       #   the RubyLLM/OpenAI provider boundary for models that need
       #   max_completion_tokens
+      # :reek:TooManyStatements -- one guarded param per LLM tuning knob, with provider-specific max_tokens handling
       def build_run_config(config)
         model_spec = config.models.first
+        llm        = config.llm
         params     = {}
 
-        temp = config.llm.temperature
+        temp = llm.temperature
         params[:temperature] = temp if temp && model_supports_temperature?(model_spec)
 
-        max = config.llm.max_tokens
+        max = llm.max_tokens
         # Local providers (Ollama, LM Studio) have a small total context window
         # (input + output combined, typically 32768 tokens for qwen3-class models).
         # Sending the cloud default of 32767 as num_predict leaves almost no room
@@ -158,13 +162,13 @@ module AIA
         local = model_spec&.local_provider?
         params[:max_tokens] = max if max && !(local && max == DEFAULT_LOCAL_MAX_TOKENS)
 
-        tp = config.llm.top_p
+        tp = llm.top_p
         params[:top_p] = tp if tp
 
-        fp = config.llm.frequency_penalty
+        fp = llm.frequency_penalty
         params[:frequency_penalty] = fp if fp && fp != 0.0
 
-        pp = config.llm.presence_penalty
+        pp = llm.presence_penalty
         params[:presence_penalty] = pp if pp && pp != 0.0
 
         RobotLab::RunConfig.new(**params)

data/lib/aia/robot_namer.rb

@@ -103,14 +103,8 @@ module AIA
     end
 
     def unique_name(base)
-      @used_names[base] ||= 0
-      @used_names[base] += 1
-
-      if @used_names[base] == 1
-        base
-      else
-        "#{base}#{@used_names[base]}"
-      end
+      count = @used_names[base] = (@used_names[base] || 0) + 1
+      count == 1 ? base : "#{base}#{count}"
     end
   end
 end

data/lib/aia/session.rb

@@ -23,6 +23,7 @@ require_relative "tool_filter_registry"
 require_relative "chat_loop"
 
 module AIA
+  # :reek:TooManyInstanceVariables -- session hub wires presenter, trackers, handlers, and robot; each collaborator is a named field
   class Session
     include ContentExtractor
 
@@ -35,14 +36,17 @@ module AIA
 
     # Starts the session, processing all prompts in the pipeline and then
     # optionally starting an interactive chat session.
+    # :reek:TooManyStatements -- session boot script: build robot, startup coordination, optional immediate chat, pipeline run, chat handoff
     def start
+      cfg = AIA.config
+
       # Build robot or network
-      @robot = RobotFactory.build(AIA.config)
+      @robot = RobotFactory.build(cfg)
       AIA.client = @robot
 
       # Run all startup coordination: MCP, tools, filters, task board, bus
       coordinator = StartupCoordinator.new(robot: @robot, ui_presenter: @ui_presenter)
-      coordinator.run(AIA.config)
+      coordinator.run(cfg)
       @filters     = coordinator.filters
       @mcp_manager = coordinator.mcp_manager
 
@@ -63,7 +67,7 @@ module AIA
         input_collector: @input_collector,
         ui_presenter:    @ui_presenter,
         session_tracker: @session_tracker
-      ).process(AIA.config)
+      ).process(cfg)
 
       # Start chat mode after all prompts are processed
       return unless AIA.chat?

data/lib/aia/session_tracker.rb

@@ -97,61 +97,26 @@ module AIA
 
     # Expand a network SimpleFlow::Result into one turn entry per robot.
     # Computes TF-IDF similarity of each response against the first.
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    # :reek:TooManyStatements -- collect entries and texts in one pass, then score and accumulate; splitting hides the pairing
     def record_network_turn(input:, flow_result:, decisions: nil, elapsed: nil)
       @turn_count += 1
       now = Time.now
 
       # Collect robot data in order for similarity scoring
-      robot_entries = []
+      robot_entries  = []
       response_texts = []
 
-      # rubocop:disable Metrics/BlockLength
       flow_result.context.each do |task_name, robot_result|
         next if task_name == :run_params
         next unless robot_result.respond_to?(:raw)
 
-        raw = robot_result.raw
-        input_tokens  = (raw.respond_to?(:input_tokens) && raw.input_tokens) || 0
-        output_tokens = (raw.respond_to?(:output_tokens) && raw.output_tokens) || 0
-        tokens = input_tokens + output_tokens
-
-        model_id = extract_model_id_from_raw(raw)
-        model_id ||= robot_result.respond_to?(:robot_name) ? robot_result.robot_name : task_name.to_s
-
-        cost = tokens.positive? ? compute_cost_for_model(model_id, input_tokens, output_tokens) : 0.0
-        robot_elapsed = robot_result.respond_to?(:duration) ? (robot_result.duration || 0) : 0
-
-        text = if robot_result.respond_to?(:reply)
-                 robot_result.reply.to_s
-               elsif robot_result.respond_to?(:content)
-                 robot_result.content.to_s
-               else
-                 ""
-               end
-        # rubocop:enable Metrics/BlockLength
-        response_texts << text
-
-        robot_entries << {
-          model: model_id,
-          input_length: input.to_s.length,
-          input_tokens: input_tokens,
-          output_tokens: output_tokens,
-          tokens: tokens,
-          cost: cost,
-          elapsed: robot_elapsed,
-          decisions: decisions&.to_h,
-          timestamp: now
-        }
+        response_texts << extract_response_text(robot_result)
+        robot_entries  << network_robot_entry(task_name, robot_result,
+                                              input: input, decisions: decisions, now: now)
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
       # Compute similarity scores (first model is reference)
-      scores = if robot_entries.size > 1
-                 SimilarityScorer.score(response_texts)
-               else
-                 Array.new(robot_entries.size)
-               end
+      scores = robot_entries.size > 1 ? SimilarityScorer.score(response_texts) : Array.new(robot_entries.size)
 
       robot_entries.each_with_index do |entry, i|
         entry[:similarity] = scores[i]
@@ -161,6 +126,39 @@ module AIA
       end
     end
 
+    # One turn entry for a single robot's result within a network flow.
+    def network_robot_entry(task_name, robot_result, input:, decisions:, now:)
+      raw = robot_result.raw
+      input_tokens  = (raw.respond_to?(:input_tokens) && raw.input_tokens) || 0
+      output_tokens = (raw.respond_to?(:output_tokens) && raw.output_tokens) || 0
+      tokens = input_tokens + output_tokens
+
+      model_id = extract_model_id_from_raw(raw)
+      model_id ||= robot_result.respond_to?(:robot_name) ? robot_result.robot_name : task_name.to_s
+
+      {
+        model: model_id,
+        input_length: input.to_s.length,
+        input_tokens: input_tokens,
+        output_tokens: output_tokens,
+        tokens: tokens,
+        cost: tokens.positive? ? compute_cost_for_model(model_id, input_tokens, output_tokens) : 0.0,
+        elapsed: robot_result.respond_to?(:duration) ? (robot_result.duration || 0) : 0,
+        decisions: decisions&.to_h,
+        timestamp: now
+      }
+    end
+
+    def extract_response_text(robot_result)
+      if robot_result.respond_to?(:reply)
+        robot_result.reply.to_s
+      elsif robot_result.respond_to?(:content)
+        robot_result.content.to_s
+      else
+        ""
+      end
+    end
+
     def extract_model_id_from_raw(raw)
       return nil unless raw
       return raw.model_id if raw.respond_to?(:model_id) && raw.model_id