aia 1.1.1 → 2.0.0.0.pre.beta2

data/lib/aia/handler_protocol.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# lib/aia/handler_protocol.rb
+#
+# Uniform interface for all turn-level handlers.
+# Include this module and implement handle(context) where context
+# is an AIA::HandlerContext value object.
+
+module AIA
+  module HandlerProtocol
+    # Process a turn. Each handler reads only the context fields it needs.
+    #
+    # @param context [AIA::HandlerContext]
+    # @return handler-specific result (String content, Boolean, or nil)
+    def handle(context)
+      raise NotImplementedError, "#{self.class} must implement #handle(context)"
+    end
+  end
+end

data/lib/aia/history_transfer.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# lib/aia/history_transfer.rb
+#
+# Stateless module for transferring conversation history between robots.
+# Extracted from RobotFactory to isolate the history transfer concern.
+
+module AIA
+  module HistoryTransfer
+    module_function
+
+    # Replay conversation history from an old robot to a new one.
+    #
+    # Performance: O(N) API calls where N = number of user messages.
+    # Each user message triggers a full LLM round-trip on the new model.
+    # For a 10-turn conversation with a local model (~1s/turn), expect ~10s.
+    # For a cloud model (~2-5s/turn), expect 20-50s. MCP/tools are disabled
+    # during replay to avoid side effects.
+    def replay_history(old_robot, new_robot)
+      return unless old_robot.respond_to?(:messages)
+
+      old_robot.messages.each do |msg|
+        next unless msg.respond_to?(:role) && msg.role == :user
+        new_robot.run(msg.content, mcp: :none, tools: :none)
+      end
+    rescue StandardError => e
+      $stderr.puts "Warning: History replay failed: #{e.message}"
+    end
+
+    # Summarize conversation history and inject into new robot.
+    #
+    # Performance: Exactly 2 API calls regardless of conversation length.
+    # 1) Summarize on old model (input tokens proportional to conversation)
+    # 2) Inject summary into new model (small fixed-size prompt)
+    # Faster than :replay for conversations with >2 turns, but loses
+    # per-turn context fidelity. Total latency ~4-10s for cloud models.
+    def summarize_history(old_robot, new_robot)
+      return unless old_robot.respond_to?(:messages) && old_robot.messages.any?
+
+      summary_lines = old_robot.messages.map do |msg|
+        "#{msg.role}: #{msg.content}" if msg.respond_to?(:role)
+      end.compact
+
+      return if summary_lines.empty?
+
+      summary_prompt = "Summarize this conversation concisely for context transfer:\n#{summary_lines.join("\n")}"
+      summary = old_robot.run(summary_prompt, mcp: :none, tools: :none)
+      content = summary.respond_to?(:reply) ? summary.reply : summary.to_s
+
+      new_robot.run("Context from previous conversation: #{content}", mcp: :none, tools: :none)
+    rescue StandardError => e
+      $stderr.puts "Warning: History summarization failed: #{e.message}"
+    end
+  end
+end

data/lib/aia/input_collector.rb

@@ -3,17 +3,17 @@
 
 module AIA
   class InputCollector
-    # Collect variable values from user input via HistoryManager
+    # Collect variable values from user input via VariableInputCollector
     def collect(parameters)
       return {} if parameters.nil? || parameters.empty?
 
       values = {}
-      input_manager = AIA::HistoryManager.new
+      input_manager = AIA::VariableInputCollector.new
 
       parameters.each do |name, default|
         value = input_manager.request_variable_value(
           variable_name: name,
-          default_value: default,
+          default_value: default
         )
         values[name] = value
       end

data/lib/aia/layered_orchestrator.rb

@@ -0,0 +1,471 @@
+# frozen_string_literal: true
+
+# lib/aia/layered_orchestrator.rb
+#
+# Three-tier agent orchestration for complex application builds.
+#
+# Tier 1 — Orchestrator (Tobor)
+#   Receives full application requirements. Decomposes them into
+#   independent architectural layers (e.g. infrastructure, data models,
+#   auth, routes, views). Each layer is a distinct technical concern.
+#
+# Tier 2 — Lead Agents (one per layer, run in parallel via Async::Barrier)
+#   Each lead agent receives its layer's requirements and breaks them
+#   into specific implementation tasks, assigning a specialist type to
+#   each task.
+#
+# Tier 3 — Specialist Robots (one per task, all run in parallel via Async::Barrier)
+#   Each specialist receives a focused, concrete task and produces the
+#   actual implementation artifact: a code file, migration, spec, or
+#   configuration block.
+#
+# After all layers complete, Tobor synthesizes a final integration
+# summary showing how the pieces fit together.
+
+require 'json'
+require 'fileutils'
+require 'async'
+
+module AIA
+  class LayeredOrchestrator
+    include ContentExtractor
+    include HandlerProtocol
+
+    MAX_LAYERS = 5
+    MAX_TASKS_PER_LAYER = 4
+
+    BUILD_BANNER = <<~BANNER
+      ╔══════════════════════════════════════════════════════════╗
+      ║           LAYERED ORCHESTRATION — 3-TIER BUILD           ║
+      ╚══════════════════════════════════════════════════════════╝
+    BANNER
+
+    # Tier 1 prompt: decompose requirements into layers
+    # Deliberately short and directive to minimise qwen3 think-block noise.
+    LAYER_DECOMPOSE_PROMPT = <<~PROMPT
+      TASK: Decompose the application requirements below into architectural layers.
+      RESPOND WITH ONLY A JSON ARRAY. No explanation. No markdown. No code fences.
+
+      JSON schema (array of objects):
+      name        - snake_case layer identifier
+      title       - short human-readable title
+      description - one sentence describing what this layer covers
+      requirements - comma-separated list of things to implement in this layer
+
+      Rules: 3 to %{max_layers} layers. Infrastructure first, UI last.
+
+      APPLICATION REQUIREMENTS:
+      %{requirements}
+
+      JSON ARRAY RESPONSE:
+    PROMPT
+
+    # Tier 2 prompt: lead agent decomposes its layer into tasks
+    TASK_DECOMPOSE_PROMPT = <<~PROMPT
+      TASK: Break the %{layer_title} layer into implementation tasks.
+      RESPOND WITH ONLY A JSON ARRAY. No explanation. No markdown. No code fences.
+
+      JSON schema (array of objects):
+      title      - short task title
+      specialist - specialist role name (e.g. sequel-migration-writer)
+      artifact   - exact filename to produce (e.g. db/migrations/001_create_users.rb)
+      prompt     - self-contained instruction for the specialist
+
+      Rules: 2 to %{max_tasks} tasks. Each task produces exactly one file.
+
+      LAYER: %{layer_title}
+      REQUIREMENTS: %{requirements}
+
+      JSON ARRAY RESPONSE:
+    PROMPT
+
+    # Layer synthesis prompt
+    LAYER_SYNTHESIS_PROMPT = <<~PROMPT
+      You implemented the %{layer_title} layer. Here are the artifacts produced
+      by your specialist team:
+
+      %{task_results}
+
+      Write a brief (3-5 sentence) integration summary: what was built, how the
+      artifacts fit together, and what the next layer depends on from this one.
+    PROMPT
+
+    # Final synthesis prompt for Tobor
+    FINAL_SYNTHESIS_PROMPT = <<~PROMPT
+      All architectural layers of the application have been built by the agent teams.
+      Here is what each layer produced:
+
+      %{layer_summaries}
+
+      Original requirements excerpt:
+      %{requirements_excerpt}
+
+      Provide a final integration summary:
+      1. What was built overall
+      2. How the layers connect (what each layer depends on from the layers below it)
+      3. The minimal steps to make the application runnable (config, migrations, startup)
+    PROMPT
+
+    def initialize(robot:, ui_presenter:, tracker:, build_dir: nil)
+      @robot        = robot
+      @ui_presenter = ui_presenter
+      @tracker      = tracker
+      @build_dir    = build_dir || default_build_dir
+    end
+
+    def default_build_dir
+      File.join(Dir.pwd, "orchestrated_build_#{Time.now.strftime('%Y%m%d_%H%M%S')}")
+    end
+
+    # Print orchestration progress to stdout so it appears inline with the chat.
+    # (display_info uses $stderr which is invisible in interactive sessions.)
+    def say(msg)
+      $stdout.puts msg
+      $stdout.flush
+    end
+
+    attr_writer :robot
+
+    # Entry point called by SpecialModeHandler.
+    #
+    # @param context [HandlerContext] — reads context.prompt as requirements text
+    # @return [String, nil] final synthesis or nil on failure
+    # :reek:TooManyStatements -- single orchestration script (banner, tier 1-3 waves, synthesis, report); the narrative order is the value
+    # :reek:DuplicateMethodCall -- say("") prints deliberate blank separator lines between build phases; not a hoistable value
+    def handle(context)
+      requirements = context.prompt
+      primary      = @robot.chief
+
+      FileUtils.mkdir_p(@build_dir)
+      print_build_banner(requirements)
+
+      # Tier 1: Tobor decomposes requirements into layers
+      layers = decompose_to_layers(primary, requirements)
+      if layers.empty?
+        say("Could not decompose requirements into layers. Aborting orchestration.")
+        return nil
+      end
+
+      display_layer_plan(layers)
+
+      # Tier 2: All lead agents run in parallel (Async::Barrier)
+      say("Running #{layers.size} lead agents in parallel...")
+      layer_task_map = run_leads_wave(layers)
+
+      if layer_task_map.values.all?(&:empty?)
+        say("All lead agents failed. Aborting orchestration.")
+        raise OrchestratorError, "All lead agents failed to produce tasks"
+      end
+
+      # Tier 3: All specialists run in parallel (Async::Barrier)
+      say("")
+      say("Running specialists in parallel...")
+      specialist_results = run_specialists_wave(layer_task_map)
+
+      # Assemble layer_results for synthesis (same shape as the former sequential approach)
+      layer_results = build_layer_results(layers, layer_task_map, specialist_results)
+
+      # Final synthesis by Tobor
+      say("")
+      say("━━━ Tobor synthesizing all #{layers.size} layers ━━━")
+      final_result = synthesize_all(primary, requirements, layers, layer_results)
+      final_text   = extract_content(final_result)
+
+      save_final_report(final_text)
+      say("Build complete: #{@build_dir}")
+
+      record_final_turn(requirements, final_text)
+      final_text
+    rescue StandardError => e
+      report_orchestration_error(e)
+      nil
+    end
+
+    private
+
+    def print_build_banner(requirements)
+      say("")
+      BUILD_BANNER.each_line { |line| say(line.chomp) }
+      say("Requirements: #{requirements.lines.first.strip}")
+      say("Build output: #{@build_dir}")
+      say("")
+    end
+
+    def record_final_turn(requirements, final_text)
+      @tracker.record_turn(
+        model:  AIA.config.models.first.name,
+        input:  requirements,
+        result: final_text
+      )
+    end
+
+    def report_orchestration_error(error)
+      say("✗ Orchestration error: #{error.class}: #{error.message}")
+      error.backtrace&.first(5)&.each { |line| say("    #{line}") }
+    end
+
+    # Tier 1: use a probe robot to decompose requirements into layer specs
+    # :reek:TooManyStatements -- probe run plus parse-failure diagnostics and rescue reporting
+    def decompose_to_layers(robot, requirements)
+      say("Tier 1 ▶ #{robot.name} decomposing requirements into layers...")
+      probe  = build_probe(robot.name + "-layer-probe")
+      prompt = LAYER_DECOMPOSE_PROMPT % {
+        requirements: requirements,
+        max_layers:   MAX_LAYERS
+      }
+
+      result  = probe.run(prompt, mcp: :none, tools: :none)
+      content = extract_content(result)
+      layers  = parse_json_array(content)
+
+      if layers.empty?
+        preview = content.to_s.gsub(%r{<think>.*?</think>}m, '').strip[0, 300]
+        say("  ⚠  Layer decomposition parse failed.")
+        say("  Raw response preview: #{preview}")
+      end
+
+      layers.first(MAX_LAYERS)
+    rescue StandardError => e
+      say("  ✗ decompose_to_layers failed: #{e.class}: #{e.message}")
+      e.backtrace&.first(3)&.each { |line| say("    #{line}") }
+      []
+    end
+
+    def display_layer_plan(layers)
+      say("Tier 1 ▶ #{layers.size} layers identified:")
+      layers.each_with_index do |layer, i|
+        say("  #{i + 1}. #{layer['title']}: #{layer['description']}")
+      end
+    end
+
+    # Tier 2 Wave: run all lead agents in parallel via Async::Barrier.
+    # Each lead decomposes its layer into task specifications.
+    #
+    # @param layers [Array<Hash>] layer specs from Tier 1
+    # @return [Hash{ String => Array<Hash> }] layer_name => task list ([] on failure)
+    # :reek:TooManyStatements -- per-layer async fan-out with per-layer error capture; the barrier plumbing is inherent
+    def run_leads_wave(layers)
+      results = {}
+
+      Sync do
+        barrier = Async::Barrier.new
+        layers.each do |layer|
+          barrier.async do
+            name   = layer['name']
+            title  = layer['title']
+            probe  = build_probe("#{name}-lead")
+            prompt = TASK_DECOMPOSE_PROMPT % {
+              layer_title:  title,
+              requirements: layer['requirements'].to_s,
+              max_tasks:    MAX_TASKS_PER_LAYER
+            }
+            result = probe.run(prompt, mcp: :none, tools: :none)
+            tasks  = parse_json_array(extract_content(result)).first(MAX_TASKS_PER_LAYER)
+            say("  ✓ #{title} lead: #{tasks.size} task(s)")
+            results[name] = tasks
+          rescue => e
+            say("  ✗ #{title} lead failed: #{e.message}")
+            results[name] = []
+          end
+        end
+        barrier.wait
+      end
+
+      results
+    end
+
+    # Tier 3 Wave: run all specialists in parallel via Async::Barrier.
+    # Flattens tasks from all layers into a single barrier so specialists
+    # across all layers execute concurrently.
+    #
+    # @param layer_task_map [Hash{ String => Array<Hash> }] output of run_leads_wave
+    # @return [Hash{ String => Hash }] "layer_name|artifact_path" => result hash
+    # :reek:TooManyStatements -- per-task async fan-out with success/failure result recording; the barrier plumbing is inherent
+    def run_specialists_wave(layer_task_map)
+      jobs = layer_task_map.flat_map do |layer_name, tasks|
+        tasks.map { |task| { layer_name: layer_name, task: task } }
+      end
+
+      results = {}
+
+      # rubocop:disable Metrics/BlockLength
+      Sync do
+        barrier = Async::Barrier.new
+        jobs.each do |job|
+          barrier.async do
+            task       = job[:task]
+            artifact   = task['artifact']
+            title      = task['title']
+            specialist = task['specialist']
+            key        = "#{job[:layer_name]}|#{artifact}"
+            probe      = build_probe("#{specialist}-specialist")
+
+            full_prompt = "Artifact to produce: #{artifact}\n\n#{task['prompt']}"
+            result      = probe.run(full_prompt, mcp: :none, tools: :none)
+            output      = extract_content(result)
+
+            save_artifact(artifact, output)
+            say("    ✓ #{artifact}")
+
+            results[key] = {
+              task:       title,
+              specialist: specialist,
+              artifact:   artifact,
+              output:     output
+            }
+          rescue => e
+            say("    ✗ #{artifact} failed: #{e.message}")
+            results[key] = {
+              task:       title,
+              specialist: specialist,
+              artifact:   artifact,
+              output:     "[FAILED: #{e.message}]"
+            }
+          end
+        end
+        # rubocop:enable Metrics/BlockLength
+        barrier.wait
+      end
+      results
+    end
+
+    # Assemble the layer_results array expected by synthesize_all.
+    # Shape: [{ layer:, tasks: [result_hashes], summary: }]
+    #
+    # @param layers [Array<Hash>] original layer specs
+    # @param layer_task_map [Hash] output of run_leads_wave
+    # @param specialist_results [Hash] output of run_specialists_wave
+    # @return [Array<Hash>]
+    def build_layer_results(layers, layer_task_map, specialist_results)
+      layers.map do |layer|
+        name  = layer['name']
+        title = layer['title']
+        tasks_for_layer = layer_task_map[name] || []
+        task_results = tasks_for_layer.map do |task|
+          key = "#{name}|#{task['artifact']}"
+          specialist_results[key] || {
+            task:       task['title'],
+            specialist: task['specialist'],
+            artifact:   task['artifact'],
+            output:     "[FAILED: no result]"
+          }
+        end
+
+        summary = synthesize_layer_from_results(title, task_results)
+        say("  ✓ #{title} synthesis complete")
+        { layer: title, tasks: task_results, summary: summary }
+      end
+    end
+
+    # Synthesize all task outputs for a layer into an integration summary.
+    # Uses a fresh probe robot (no conversation history).
+    def synthesize_layer_from_results(layer_title, task_results)
+      results_text = task_results.map do |r|
+        "### #{r[:task]} — #{r[:artifact]}\n#{r[:output]}"
+      end.join("\n\n---\n\n")
+
+      prompt = LAYER_SYNTHESIS_PROMPT % {
+        layer_title:  layer_title,
+        task_results: results_text
+      }
+
+      probe  = build_probe("#{layer_title.downcase.gsub(/\s+/, '-')}-synthesis")
+      result = probe.run(prompt, mcp: :none, tools: :none)
+      extract_content(result)
+    rescue StandardError
+      "(layer synthesis failed)"
+    end
+
+    # Tobor synthesizes all layer summaries into a final integration report
+    def synthesize_all(primary, requirements, layers, layer_results)
+      summaries = layer_results.each_with_index.map do |lr, i|
+        header = "## Layer #{i + 1}: #{lr[:layer]}"
+        tasks  = Array(lr[:tasks]).map { |t| "- #{t[:artifact]}: #{t[:task]}" }.join("\n")
+        "#{header}\n#{tasks}\n\nSummary: #{lr[:summary]}"
+      end.join("\n\n")
+
+      primary.run(
+        FINAL_SYNTHESIS_PROMPT % {
+          layer_summaries:      summaries,
+          requirements_excerpt: requirements.lines.first(15).join
+        },
+        mcp: :none, tools: :none
+      )
+    end
+
+    # Parse JSON array from model output.
+    # Tries multiple extraction strategies to handle think blocks,
+    # markdown fences, prose before/after the JSON, and partial wrapping.
+    def parse_json_array(content)
+      return [] if content.nil? || content.strip.empty?
+
+      # Strip think blocks (qwen3 reasoning models wrap output in <think>...)
+      text = content.gsub(%r{<think>.*?</think>}m, '').strip
+
+      # Strategy 1: extract content from markdown code fences
+      if (m = text.match(/```(?:json)?\s*\n?(.*?)```/m))
+        candidate = m[1].strip
+        result = try_json_parse(candidate)
+        return result unless result.empty?
+      end
+
+      # Strategy 2: find the first [...] block in the response
+      if (m = text.match(/(\[[\s\S]*\])/m))
+        result = try_json_parse(m[1])
+        return result unless result.empty?
+      end
+
+      # Strategy 3: parse the whole stripped text
+      try_json_parse(text)
+    end
+
+    def try_json_parse(text)
+      result = JSON.parse(text.strip)
+      result.is_a?(Array) ? result.grep(Hash) : []
+    rescue JSON::ParserError
+      []
+    end
+
+    # Build a short-lived probe robot with no conversation history.
+    # Uses the primary model spec so the provider is correctly wired.
+    def build_probe(name)
+      config     = AIA.config
+      run_config = RobotFactory.build_run_config(config)
+      model_spec = config.models.first
+
+      RobotFactory.build_robot(
+        model_spec,
+        name:          name,
+        system_prompt: nil,
+        config:        run_config
+      )
+    end
+
+    # Write an artifact to the build directory.
+    # Strips markdown code fences if the entire output is wrapped in them.
+    def save_artifact(artifact_path, content)
+      return unless content && !content.strip.empty?
+
+      # Strip a single wrapping code fence if the whole content is fenced
+      code = content.strip
+      if (m = code.match(/\A```\w*\n(.*)\n```\z/m))
+        code = m[1]
+      end
+
+      dest = File.join(@build_dir, artifact_path)
+      FileUtils.mkdir_p(File.dirname(dest))
+      File.write(dest, code)
+    rescue StandardError => e
+      say("    ⚠  Could not save #{artifact_path}: #{e.message}")
+    end
+
+    # Write the integration report to BUILD_DIR/INTEGRATION_REPORT.md
+    def save_final_report(text)
+      dest = File.join(@build_dir, "INTEGRATION_REPORT.md")
+      File.write(dest, text)
+      say("Integration report: #{dest}")
+    rescue StandardError
+      # best-effort
+    end
+  end
+end

data/lib/aia/logger.rb

@@ -76,22 +76,23 @@ module AIA
       def configure_llm_logger
         return unless defined?(RubyLLM)
 
-        logger = llm_logger
+        logger     = llm_logger
+        llm_config = RubyLLM.config
 
         # Set our logger on the RubyLLM config object
-        if RubyLLM.config.respond_to?(:logger=)
-          RubyLLM.config.logger = logger
+        if llm_config.respond_to?(:logger=)
+          llm_config.logger = logger
         end
 
         # Also set log_file and log_level in case the logger gets recreated
-        if RubyLLM.config.respond_to?(:log_file=)
+        if llm_config.respond_to?(:log_file=)
           file = effective_log_file(logger_config_for(:llm))
-          RubyLLM.config.log_file = resolve_log_file_io(file)
+          llm_config.log_file = resolve_log_file_io(file)
         end
 
-        if RubyLLM.config.respond_to?(:log_level=)
+        if llm_config.respond_to?(:log_level=)
           level = effective_log_level(logger_config_for(:llm))
-          RubyLLM.config.log_level = LOG_LEVELS.fetch(level, Lumberjack::Severity::WARN)
+          llm_config.log_level = LOG_LEVELS.fetch(level, Lumberjack::Severity::WARN)
         end
 
         # Reset the memoized @logger on RubyLLM module so next call uses our config
@@ -124,10 +125,9 @@ module AIA
           config.log_file = resolve_log_file_io(file)
         end
 
-        if config.respond_to?(:log_level=)
-          level = effective_log_level(logger_config_for(:mcp))
-          config.log_level = LOG_LEVELS.fetch(level, Lumberjack::Severity::WARN)
-        end
+        return unless config.respond_to?(:log_level=)
+        level = effective_log_level(logger_config_for(:mcp))
+        config.log_level = LOG_LEVELS.fetch(level, Lumberjack::Severity::WARN)
       end
 
       # Convert log file specification to IO object or file path
@@ -160,6 +160,27 @@ module AIA
         @test_mode = false
       end
 
+      # Update existing loggers' levels in-place from current config.
+      # Call this after runtime config changes (e.g. /config debug = false)
+      # so the log level takes effect immediately without recreating loggers.
+      def reconfigure_levels!
+        return if test_mode?
+
+        %i[aia llm mcp].each do |system|
+          logger = instance_variable_get(:"@#{system}_logger")
+          next unless logger
+
+          config  = logger_config_for(system)
+          level   = effective_log_level(config, system)
+          numeric = LOG_LEVELS.fetch(level, Lumberjack::Severity::WARN)
+          logger.level = numeric
+        end
+
+        # Keep RubyLLM / MCP configs in sync so they don't override us
+        configure_llm_logger
+        configure_mcp_logger
+      end
+
       # =======================================================================
       # Test Mode Support
       # =======================================================================
@@ -287,23 +308,21 @@ module AIA
       # @param file [String] The file config value
       # @param flush [Boolean] If true, flush immediately (no buffering)
       # @return [Lumberjack::Device] The device instance
+      # :reek:BooleanParameter -- flush: maps directly onto Lumberjack's autoflush; two constructors would obscure that single toggle
       def create_device(file, flush: true)
-        # buffer_size: 0 means immediate flush (no buffering)
-        buffer_size = flush ? 0 : 8192
-
         case file.to_s.upcase
         when 'STDOUT'
-          Lumberjack::Device::Writer.new($stdout, buffer_size: buffer_size)
+          Lumberjack::Device::Writer.new($stdout, autoflush: flush)
         when 'STDERR'
-          Lumberjack::Device::Writer.new($stderr, buffer_size: buffer_size)
+          Lumberjack::Device::Writer.new($stderr, autoflush: flush)
         else
           path = File.expand_path(file)
-          # Use date rolling for file-based logs
-          # Multiple loggers can safely write to the same file
-          Lumberjack::Device::DateRollingLogFile.new(
+          # Daily date rolling via Logger::LogDevice, which also makes the
+          # file safe for multiple loggers to write to
+          Lumberjack::Device::LogFile.new(
             path,
-            roll: :daily,
-            buffer_size: buffer_size
+            shift_age: 'daily',
+            autoflush: flush
           )
         end
       end
@@ -313,12 +332,13 @@ module AIA
       # @param system [Symbol] The system (:aia, :llm, :mcp)
       # @return [ConfigSection, nil] The configuration section
       def logger_config_for(system)
-        return nil unless AIA.config&.logger
+        logger_cfg = AIA.config&.logger
+        return nil unless logger_cfg
 
         case system
-        when :aia then AIA.config.logger.aia
-        when :llm then AIA.config.logger.llm
-        when :mcp then AIA.config.logger.mcp
+        when :aia then logger_cfg.aia
+        when :llm then logger_cfg.llm
+        when :mcp then logger_cfg.mcp
         end
       rescue NoMethodError
         nil