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

data/lib/aia/similarity_scorer.rb

@@ -15,11 +15,13 @@ module AIA
     #
     # @param responses [Array<String>] ordered response texts (first is reference)
     # @return [Array<Float, nil>] similarity scores (nil for first, 0.0..1.0 for rest)
+    # :reek:TooManyStatements -- guarded scoring: two early-out shapes, TF-IDF fit/transform, pairwise map, rescue fallback
     def self.score(responses)
-      return Array.new(responses.size) if responses.size < 2
+      count = responses.size
+      return Array.new(count) if count < 2
 
       texts = responses.map { |r| r.to_s.strip }
-      return Array.new(responses.size) if texts.first.empty?
+      return Array.new(count) if texts.first.empty?
 
       tfidf = Classifier::TFIDF.new
       tfidf.fit(texts)
@@ -33,7 +35,7 @@ module AIA
         end
       end
     rescue StandardError
-      Array.new(responses.size)
+      Array.new(count)
     end
   end
 end

data/lib/aia/special_mode_handler.rb

@@ -109,30 +109,63 @@ module AIA
       false
     end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    # :reek:TooManyStatements -- benchmark-instrumented pipeline: decompose, concurrent fan-out, synthesis, reporting
     def handle_decomposition(prompt)
       require_relative 'prompt_decomposer'
-      total_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      total_t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
       @ui_presenter.display_info("Decomposing prompt into sub-tasks...")
-      decomposer    = PromptDecomposer.new(@robot)
-      decompose_t0  = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      subtasks      = decomposer.decompose(prompt)
-      decompose_dur = Process.clock_gettime(Process::CLOCK_MONOTONIC) - decompose_t0
+      decomposer = PromptDecomposer.new(@robot)
+      subtasks, decompose_dur = Timing.timed { decomposer.decompose(prompt) }
 
       if subtasks.empty?
         @ui_presenter.display_info("Prompt cannot be meaningfully decomposed. Running normally.")
         return false
       end
 
+      announce_subtasks(subtasks)
+
+      results, timings, raw_subtasks, parallel_wall = run_and_time_subtasks(subtasks)
+
+      raise DecomposeError, "All sub-tasks failed" if results.all?(&:nil?)
+
+      @ui_presenter.display_info("Synthesizing results...")
+      final, synth_dur = Timing.timed { decomposer.synthesize(prompt, results.compact) }
+
+      total_wall = Process.clock_gettime(Process::CLOCK_MONOTONIC) - total_t0
+
+      display_decompose_benchmark(decompose_dur: decompose_dur, timings: timings,
+                                  synth_dur: synth_dur, parallel_wall: parallel_wall,
+                                  total_wall: total_wall)
+      display_decompose_token_metrics(raw_subtasks, final, total_wall)
+
+      present_result(final, prompt: prompt, ui_presenter: @ui_presenter, tracker: @tracker)
+      true
+    rescue StandardError => e
+      @ui_presenter.display_info("Decomposition failed: #{e.message}. Falling back to normal mode.")
+      false
+    end
+
+    def announce_subtasks(subtasks)
       @ui_presenter.display_info("Decomposed into #{subtasks.size} sub-tasks:")
       subtasks.each_with_index { |t, i| @ui_presenter.display_info("  #{i + 1}. #{t}") }
+    end
 
-      timings         = Array.new(subtasks.size, 0.0)
-      raw_subtasks    = Array.new(subtasks.size)
-      wall_start      = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    # Fan out sub-tasks concurrently, capturing per-task and wall-clock timing.
+    # Returns [results, timings, raw_subtasks, parallel_wall].
+    def run_and_time_subtasks(subtasks)
+      timings      = Array.new(subtasks.size, 0.0)
+      raw_subtasks = Array.new(subtasks.size)
+      results, parallel_wall = Timing.timed { run_subtasks_concurrently(subtasks, timings, raw_subtasks) }
+      [results, timings, raw_subtasks, parallel_wall]
+    end
 
-      results = Sync do
+    # Run all sub-tasks concurrently, recording per-task timing and raw results
+    # into the caller-supplied arrays. Returns extracted contents (nil per failure).
+    # :reek:DuplicateMethodCall -- clock_gettime is read at task start and again at each outcome; each read must be "now"
+    # :reek:TooManyStatements -- async fan-out with per-task timing capture on both success and failure paths
+    def run_subtasks_concurrently(subtasks, timings, raw_subtasks)
+      Sync do
         barrier = Async::Barrier.new
         tasks = subtasks.each_with_index.map do |task, i|
           barrier.async do
@@ -151,21 +184,13 @@ module AIA
         barrier.wait
         tasks.map(&:wait)
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+    end
 
-      parallel_wall    = Process.clock_gettime(Process::CLOCK_MONOTONIC) - wall_start
+    # Print the decomposition benchmark table.
+    def display_decompose_benchmark(decompose_dur:, timings:, synth_dur:, parallel_wall:, total_wall:)
       serial_est       = timings.sum
       parallel_speedup = serial_est / parallel_wall
 
-      raise DecomposeError, "All sub-tasks failed" if results.all?(&:nil?)
-
-      @ui_presenter.display_info("Synthesizing results...")
-      synth_t0  = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      final     = decomposer.synthesize(prompt, results.compact)
-      synth_dur = Process.clock_gettime(Process::CLOCK_MONOTONIC) - synth_t0
-
-      total_wall = Process.clock_gettime(Process::CLOCK_MONOTONIC) - total_start
-
       lines = ["", "Benchmark:"]
       lines << "  Decompose probe : #{format('%.2f', decompose_dur)}s"
       timings.each_with_index { |t, i| lines << "  Sub-task #{i + 1}      : #{format('%.2f', t)}s" }
@@ -175,21 +200,15 @@ module AIA
       lines << "  Sub-tasks concurrent  : #{format('%.2f', parallel_wall)}s  (#{format('%.1f', parallel_speedup)}x parallel speedup)"
       lines << "  Total flow wall time  : #{format('%.2f', total_wall)}s  (compare against --tokens Time for a normal run)"
       @ui_presenter.display_info(lines.join("\n"))
-
-      display_decompose_token_metrics(raw_subtasks, final, total_wall)
-
-      present_result(final, prompt: prompt, ui_presenter: @ui_presenter, tracker: @tracker)
-      true
-    rescue StandardError => e
-      @ui_presenter.display_info("Decomposition failed: #{e.message}. Falling back to normal mode.")
-      false
     end
 
+    # :reek:TooManyStatements -- ordered eligibility gates (server count, discovery, grouping) before the network run
     def handle_concurrent_mcp(prompt)
-      return false unless (AIA.config.mcp_servers || []).size > 1
+      cfg = AIA.config
+      return false unless (cfg.mcp_servers || []).size > 1
 
       discovery = MCPDiscovery.new
-      relevant = discovery.discover(AIA.config)
+      relevant = discovery.discover(cfg)
       return false if relevant.size <= 1
 
       grouper = MCPGrouper.new
@@ -198,7 +217,7 @@ module AIA
 
       @ui_presenter.display_info("Running concurrent MCP across #{groups.size} server groups...")
 
-      network = RobotFactory.build_concurrent_mcp_network(AIA.config, groups)
+      network = RobotFactory.build_concurrent_mcp_network(cfg, groups)
       result = @ui_presenter.with_spinner("Processing (concurrent)") { network.run(message: prompt) }
       extract_content(result)
 
@@ -270,6 +289,7 @@ module AIA
 
     # Aggregate token counts from all sub-task raw results plus the synthesis
     # result and display a combined metrics table. Only runs when --tokens is set.
+    # :reek:TooManyStatements -- sums token usage across sub-task results plus synthesis, then prints the metrics block
     def display_decompose_token_metrics(raw_subtasks, synthesis_result, total_elapsed)
       return unless AIA.config.flags.tokens
 

data/lib/aia/speech.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+# lib/aia/speech.rb
+#
+# Shared text-to-speech behavior for interactive handlers (ChatLoop,
+# MentionRouter). ContentExtractor duck-calls #speak on any includer
+# that responds to it, so both sides route through this one pipeline.
+
+module AIA
+  module Speech
+    private
+
+    # :reek:TooManyStatements -- two-stage TTS pipeline (convert, then play) with spinner and tempfile cleanup
+    def speak(content)
+      return unless AIA.speak?
+
+      audio   = AIA.config.audio
+      command = audio.speak_command || 'say'
+      voice   = audio.voice
+      text    = content.to_s
+      env     = {}
+      env['SPEECH_MODEL'] = audio.speech_model if audio.speech_model
+
+      if command == 'say'
+        # Local TTS: say converts and plays in one step
+        run_with_spinner("Speaking...") do
+          if voice && !voice.to_s.strip.empty?
+            system(env, command, '-v', voice, text)
+          else
+            system(env, command, text)
+          end
+        end
+      else
+        # Custom TTS script: stage 2 = convert text → audio file,
+        # stage 3 = play the file. AIA passes the output path as $2.
+        require 'tempfile'
+        tmpfile = Tempfile.new(['aia-tts-', '.mp3'])
+        tmpfile.close
+        path = tmpfile.path
+        begin
+          run_with_spinner("Converting to audio...") do
+            system(env, command, text, path)
+          end
+          if File.size?(path)
+            run_with_spinner("Speaking...") do
+              system('afplay', 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/startup_coordinator.rb

@@ -46,6 +46,7 @@ module AIA
     # --mcp-use, --mcp-skip, and KBS mcp_activate decisions), then normalizes
     # each server config via MCPConfigNormalizer before handing off to
     # MCPConnectionManager.
+    # :reek:TooManyStatements -- MCP wiring sequence: discovery, validation, normalize fallback, connect, absorb, inject
     def connect_mcp_servers(config)
       return if config.flags.no_mcp
 

data/lib/aia/streaming_runner.rb

@@ -28,6 +28,8 @@ module AIA
     # @param spinner_message [String] spinner label
     # @param tools [Array<String>, nil] tool names to allow for this turn (nil = all)
     # @return [Array(Object, String, Float)] [result, streamed_content_or_nil, elapsed_seconds]
+    # :reek:TooManyStatements -- one streaming turn: spinner lifecycle, chunk-filter closure, robot run with cleanup, timing
+    # :reek:DuplicateMethodCall -- @spinner.stop guards three distinct control paths (first chunk, exception, completion)
     def run(robot, prompt, header: "\nAI:\n   ", spinner_message: "Processing...", tools: nil)
       @spinner.reset
       @spinner.update(title: spinner_message)
@@ -107,11 +109,12 @@ module AIA
 
       max   = max_tools
       names = tools_param == :inherit ? robot_tool_names(robot) : tools_param
-      return tools_param if names.size <= max
+      size  = names.size
+      return tools_param if size <= max
 
-      dropped = names.size - max
+      dropped = size - max
       $stderr.puts(
-        "⚠ Tool list (#{names.size}) exceeds the provider limit of #{max}; " \
+        "⚠ Tool list (#{size}) exceeds the provider limit of #{max}; " \
         "sending #{max}, dropping #{dropped}. Enable --auto-tool-filter or reduce " \
         "the available tools to control which ones are sent."
       )

data/lib/aia/system_prompt_assembler.rb

@@ -18,9 +18,10 @@ module AIA
     # @param model_spec [ModelSpec, nil] optional model spec with role override
     # @return [String, nil] the assembled system prompt
     def resolve_system_prompt(config, model_spec = nil)
-      system_prompt = config.prompts.system_prompt
+      prompts_cfg   = config.prompts
+      system_prompt = prompts_cfg.system_prompt
 
-      role_id = model_spec&.role || config.prompts.role
+      role_id = model_spec&.role || prompts_cfg.role
       if role_id && !role_id.empty?
         role_content = load_role_content(config, role_id)
         if role_content
@@ -32,7 +33,7 @@ module AIA
       # Pipeline mode appends skills to each prompt text instead (pipeline_orchestrator).
       if config.flags&.chat == true
         skill_content = AIA::SkillUtils.load_skills_content(
-          Array(config.prompts&.skills),
+          Array(prompts_cfg&.skills),
           AIA::SkillUtils.skills_base_dir(config)
         )
         system_prompt = [system_prompt, skill_content].compact.join("\n\n") if skill_content
@@ -48,6 +49,7 @@ module AIA
     # @param spec [ModelSpec] this robot's model spec
     # @param roster [Array<Hash>] all robots: [{ name:, spec: }, ...]
     # @return [String]
+    # :reek:TooManyStatements -- builds the identity line plus a roster entry per teammate; one cohesive prompt fragment
     def build_identity_prompt(robot_name, spec, roster)
       provider_label = spec.provider ? " (#{spec.provider})" : ""
       lines = ["You are #{robot_name}, powered by #{spec.name}#{provider_label}."]
@@ -55,9 +57,10 @@ module AIA
       if roster.size > 1
         lines << "You are part of a team of AI robots:"
         roster.each do |entry|
-          p = entry[:spec].provider ? " (#{entry[:spec].provider})" : ""
+          entry_spec = entry[:spec]
+          p = entry_spec.provider ? " (#{entry_spec.provider})" : ""
           marker = entry[:name] == robot_name ? " ← you" : ""
-          lines << "  - #{entry[:name]}: #{entry[:spec].name}#{p}#{marker}"
+          lines << "  - #{entry[:name]}: #{entry_spec.name}#{p}#{marker}"
         end
         lines << "Users can address a specific robot with @name mentions."
       end
@@ -71,12 +74,13 @@ module AIA
     # @param role_id [String] the role identifier
     # @return [String, nil] the role file content or nil
     def load_role_content(config, role_id)
-      roles_prefix = config.prompts.roles_prefix
+      prompts_cfg  = config.prompts
+      roles_prefix = prompts_cfg.roles_prefix
       unless role_id.start_with?(roles_prefix)
         role_id = "#{roles_prefix}/#{role_id}"
       end
 
-      role_file = File.join(config.prompts.dir, "#{role_id}#{config.prompts.extname}")
+      role_file = File.join(prompts_cfg.dir, "#{role_id}#{prompts_cfg.extname}")
       return nil unless File.exist?(role_file)
 
       File.read(role_file)

data/lib/aia/task_coordinator.rb

@@ -33,6 +33,7 @@ module AIA
     # @param labels [Array<String>] labels like "robot:alice", "domain:code"
     # @param creator [String] name of the creating robot
     # @return [TrakFlow::Models::Task, nil]
+    # :reek:LongParameterList { max_params: 6 } -- one keyword per optional task attribute; callers set only what they need
     def create_task(title, assignee: nil, parent_id: nil,
                     blocked_by: [], labels: [], creator: "aia")
       return nil unless available?
@@ -40,27 +41,28 @@ module AIA
       task = TrakFlow::Models::Task.new(
         title: title, assignee: assignee, type: "task"
       )
-      task = @db.create_task(task)
+      task    = @db.create_task(task)
+      task_id = task.id
 
       @db.add_label(TrakFlow::Models::Label.new(
-                      task_id: task.id, name: "creator:#{creator}"
+                      task_id: task_id, name: "creator:#{creator}"
                     ))
 
       labels.each do |label|
         @db.add_label(TrakFlow::Models::Label.new(
-                        task_id: task.id, name: label
+                        task_id: task_id, name: label
                       ))
       end
 
       blocked_by.each do |blocker_id|
         @db.add_dependency(TrakFlow::Models::Dependency.new(
-                             source_id: blocker_id, target_id: task.id, type: "blocks"
+                             source_id: blocker_id, target_id: task_id, type: "blocks"
                            ))
       end
 
       if parent_id
         @db.add_dependency(TrakFlow::Models::Dependency.new(
-                             source_id: parent_id, target_id: task.id, type: "parent-child"
+                             source_id: parent_id, target_id: task_id, type: "parent-child"
                            ))
       end
 
@@ -74,6 +76,8 @@ module AIA
     # @param creator [String] creating robot name
     # @param ephemeral [Boolean] true for single-session plans (auto-gc)
     # @return [Hash, nil] { plan:, steps: }
+    # :reek:BooleanParameter -- ephemeral: tags a plan for auto-gc at session end; a second method would duplicate the whole build
+    # :reek:TooManyStatements -- plan build: create the plan task, then per step a child task, labels, and ordering dependency
     def create_plan(title, steps:, creator: "aia", ephemeral: false)
       return nil unless available?
 
@@ -177,6 +181,7 @@ module AIA
     # Summary of the current task board state.
     #
     # @return [String, nil]
+    # :reek:TooManyStatements -- one board report: totals line, per-assignee open/done counts, unassigned tail
     def status_summary
       return nil unless available?
 

data/lib/aia/timing.rb

@@ -0,0 +1,15 @@
+# lib/aia/timing.rb
+
+module AIA
+  # Monotonic-clock instrumentation shared by benchmark-reporting code.
+  module Timing
+    module_function
+
+    # Run the block and return [result, elapsed_seconds].
+    def timed
+      t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      result = yield
+      [result, Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0]
+    end
+  end
+end

data/lib/aia/tool_filter.rb

@@ -13,6 +13,7 @@ module AIA
   class ToolFilter
     attr_reader :tool_count, :prep_ms, :label
 
+    # :reek:BooleanParameter -- load_db:/save_db: toggle embedding-cache persistence per strategy; mode objects would multiply constructors
     def initialize(label:, db_dir: nil, load_db: false, save_db: false)
       @label      = label
       @db_dir     = db_dir

data/lib/aia/tool_filter_strategy.rb

@@ -8,6 +8,8 @@
 # After each resolve(), prints a timing table showing
 # prep and filter times for the active filter.
 
+require 'tty-table'
+
 module AIA
   class ToolFilterStrategy
     # Maps filter keys to display info.
@@ -88,26 +90,45 @@ module AIA
 
     # Display single-filter results via logger.
     def display_filter_results(key, scored)
-      meta = meta_for(key)
+      meta   = meta_for(key)
+      label  = meta[:label]
+      logger = AIA.logger
 
       if scored.empty?
-        AIA.logger.debug "[#{meta[:label]}] No tools matched (all tools available)"
+        logger.debug "[#{label}] No tools matched (all tools available)"
         return
       end
 
       names = scored.map { |e| e[:name] }.join(', ')
-      AIA.logger.debug "[#{meta[:label]}] Tools for this turn (#{scored.size}): #{names}"
+      logger.debug "[#{label}] Tools for this turn (#{scored.size}): #{names}"
 
       scored.each do |entry|
-        AIA.logger.debug "[#{meta[:label]}]   #{entry[:name]}  (#{meta[:score_label]}: #{format('%.4f', entry[:score])})"
+        logger.debug "[#{label}]   #{entry[:name]}  (#{meta[:score_label]}: #{format('%.4f', entry[:score])})"
       end
     end
 
     # Print the timing table via logger.
-    # rubocop:disable Metrics/AbcSize
+    # :reek:DuplicateMethodCall -- header and each data row map the same columns into different cells
     def display_timing_table(filter_ms_by_key)
-      columns = @filters.map do |key, filter|
-        meta = meta_for(key)
+      columns = build_timing_columns(filter_ms_by_key)
+      return if columns.empty?
+
+      header = ["Process"] + columns.map { |col| "#{col[:header]}\n#{col[:sub]}" }
+      rows   = [
+        ["prep"]   + columns.map { |col| col[:prep] },
+        ["filter"] + columns.map { |col| col[:filter] }
+      ]
+
+      alignments = [:left] + Array.new(columns.size, :right)
+      rendered   = TTY::Table.new(header, rows)
+                             .render(:unicode, multiline: true, alignments: alignments, padding: [0, 1])
+      rendered.each_line { |line| AIA.logger.debug(line.chomp) }
+    end
+
+    # Column data (header, sub-label, prep/filter cells) for each configured filter.
+    def build_timing_columns(filter_ms_by_key)
+      @filters.map do |key, filter|
+        meta   = meta_for(key)
         active = filter_ms_by_key.key?(key)
         {
           header: "Option #{meta[:letter]}",
@@ -116,25 +137,7 @@ module AIA
           filter: active ? fmt_ms(filter_ms_by_key[key]) : "--"
         }
       end
-
-      return if columns.empty?
-
-      pw = 7  # "Process" column width
-      widths = columns.map do |col|
-        [10, col[:header].length, col[:sub].length, col[:prep].length, col[:filter].length].max
-      end
-
-      lines = []
-      lines << ("┌─#{'─' * pw}─" + columns.each_with_index.map { |_, i| "┬─#{'─' * widths[i]}─" }.join + "┐")
-      lines << ("│ #{'Process'.ljust(pw)} " + columns.each_with_index.map { |col, i| "│ #{col[:header].ljust(widths[i])} " }.join + "│")
-      lines << ("│ #{' ' * pw} " + columns.each_with_index.map { |col, i| "│ #{col[:sub].ljust(widths[i])} " }.join + "│")
-      lines << ("├─#{'─' * pw}─" + columns.each_with_index.map { |_, i| "┼─#{'─' * widths[i]}─" }.join + "┤")
-      lines << ("│ #{'prep'.ljust(pw)} " + columns.each_with_index.map { |col, i| "│ #{col[:prep].rjust(widths[i])} " }.join + "│")
-      lines << ("│ #{'filter'.ljust(pw)} " + columns.each_with_index.map { |col, i| "│ #{col[:filter].rjust(widths[i])} " }.join + "│")
-      lines << ("└─#{'─' * pw}─" + columns.each_with_index.map { |_, i| "┴─#{'─' * widths[i]}─" }.join + "┘")
-      lines.each { |line| AIA.logger.debug line }
     end
-    # rubocop:enable Metrics/AbcSize
 
     def fmt_ms(ms)
       "#{ms.round(1)}ms"

data/lib/aia/tool_introspection.rb

@@ -0,0 +1,17 @@
+# lib/aia/tool_introspection.rb
+
+module AIA
+  # Shared name/description extraction for tool objects, which may be
+  # RubyLLM tools, RobotLab tools, or bare tool classes.
+  module ToolIntrospection
+    module_function
+
+    def tool_name(tool)
+      tool.respond_to?(:name) ? tool.name : tool.class.name
+    end
+
+    def tool_description(tool)
+      tool.respond_to?(:description) ? tool.description.to_s : ''
+    end
+  end
+end

data/lib/aia/tool_loader.rb

@@ -53,6 +53,7 @@ module AIA
 
     # Load tools from require_libs and tool paths, then cache the result.
     # Subsequent calls to RobotFactory.build skip this entirely if cache exists.
+    # :reek:TooManyStatements -- sequential phases: require_libs with activation retry, tool files, eager loads, discovery cache
     def load_tools(config)
       Array(config.require_libs).each do |lib|
         require lib
@@ -89,11 +90,17 @@ module AIA
       tools = discover_tools
       @tool_cache = tools
       config.loaded_tools = tools
-      config.tool_names = tools.map { |t| t.respond_to?(:name) ? t.name : t.class.name }.join(', ')
+      config.tool_names = tools.map { |t| tool_name(t) }.join(', ')
+    end
+
+    # A tool's display name: instances expose #name; bare classes fall back to the class name.
+    def tool_name(tool)
+      tool.respond_to?(:name) ? tool.name : tool.class.name
     end
 
     # Filter tools based on allowed/rejected lists and KBS decisions.
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    # :reek:TooManyStatements -- allowed filter, rejected filter, then a name-dedup pass over the tool list
+    # :reek:DuplicateMethodCall -- tool_name(t) is applied per element inside three separate filter blocks; no shared scope to hoist into
     def filtered_tools(config)
       tools = config.loaded_tools || []
       allowed = config.tools&.allowed
@@ -102,7 +109,7 @@ module AIA
       if allowed && !allowed.empty?
         allowed_list = Array(allowed).map(&:strip).map(&:downcase)
         tools = tools.select do |t|
-          name = (t.respond_to?(:name) ? t.name : t.class.name).downcase
+          name = tool_name(t).downcase
           # name is a String; Array#intersect? would raise TypeError
           allowed_list.any? { |a| name.include?(a) }
         end
@@ -111,7 +118,7 @@ module AIA
       if rejected && !rejected.empty?
         rejected_list = Array(rejected).map(&:strip).map(&:downcase)
         tools = tools.reject do |t|
-          name = (t.respond_to?(:name) ? t.name : t.class.name).downcase
+          name = tool_name(t).downcase
           # name is a String; Array#intersect? would raise TypeError
           rejected_list.any? { |r| name.include?(r) }
         end
@@ -119,7 +126,7 @@ module AIA
 
       seen = {}
       tools.select do |t|
-        name = t.respond_to?(:name) ? t.name : t.class.name
+        name = tool_name(t)
         if seen[name]
           false
         else
@@ -128,7 +135,6 @@ module AIA
         end
       end
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
     # Discover RubyLLM::Tool subclasses from ObjectSpace.
     # Skips tools that report themselves as unavailable via #available?.

data/lib/aia/tools/task_board_tool.rb

@@ -9,6 +9,7 @@
 require "json"
 
 module AIA
+  # :reek:DataClump -- each execute_<action> dispatch target receives the same LLM tool-call context
   class TaskBoardTool < RubyLLM::Tool
     description "Manage a shared task board. Create tasks for other robots, " \
                 "check what's ready, claim tasks, and report completion."

data/lib/aia/trakflow_bridge.rb

@@ -26,6 +26,7 @@ module AIA
     #
     # @param pipeline [Array<String>] prompt IDs in pipeline order
     # @return [String, nil] summary of created plan
+    # :reek:TooManyStatements -- plan build: one child task per pipeline step, chained by blocking dependencies
     def create_plan_from_pipeline(pipeline)
       return nil unless available?
 
@@ -71,15 +72,16 @@ module AIA
       case status
       when :started
         task.status = "in_progress"
-        @db.update_task(task)
       when :completed
         task.close!(reason: reason || "Completed")
-        @db.update_task(task)
       when :failed
         task.status = "blocked"
         task.append_trace("blocked", reason) if reason
-        @db.update_task(task)
+      else
+        return
       end
+
+      @db.update_task(task)
     rescue StandardError => e
       $stderr.puts "Warning: TrakFlow status update failed: #{e.message}"
     end

data/lib/aia/turn_state.rb

@@ -12,6 +12,7 @@
 # and direct test assertions).
 
 module AIA
+  # :reek:TooManyInstanceVariables -- one boolean flag per exclusive mode plus spawn/mcp details; a Hash would lose the attr_accessor API
   class TurnState
     # Exclusive mode flags — only one may be active at a time via #request.
     EXCLUSIVE_MODES = %i[