smart_brain 0.1.2 → 0.3.0

data/lib/smart_brain/adapters/smart_rag/media_metadata_extractor.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+
+module SmartBrain
+  module Adapters
+    module SmartRag
+      # Extracts technical metadata from media files (image / audio / video).
+      #
+      # Stage 1 of the media memory plan (docs/media_memory_schema.md):
+      #   - image  -> Python Pillow bridge (same pattern as MarkitdownBridge)
+      #   - audio  -> ffprobe
+      #   - video  -> ffprobe
+      #
+      # Degradation policy (D5): when a dependency is missing the extractor
+      # returns the default media object with a warning instead of raising,
+      # so ingestion can still store file-level metadata.
+      #
+      # NOTE: This component lives in smart_brain during stage 1 (testable
+      # without a SmartRAG database). Stage 3 will sync it into the SmartRAG
+      # project as SmartRAG::Core::MediaMetadataExtractor and wire it into
+      # DocumentProcessor#extract_metadata.
+      class MediaMetadataExtractor
+        IMAGE_EXTS = %w[.jpg .jpeg .png .gif .webp .bmp .tif .tiff .heic .heif].freeze
+        AUDIO_EXTS = %w[.mp3 .wav .m4a .aac .flac .ogg .oga .opus .wma .aif .aiff].freeze
+        VIDEO_EXTS = %w[.mp4 .mkv .mov .webm .avi .flv .wmv .m4v .ts .mpeg .mpg].freeze
+
+        # Wide schema shared by all three media types; type-specific fields
+        # stay nil (design decision D1).
+        DEFAULT_MEDIA = {
+          format: nil,
+          width: nil,
+          height: nil,
+          dpi: nil,
+          color_mode: nil,
+          orientation: nil,
+          exif: {},
+          duration_ms: nil,
+          bitrate_bps: nil,
+          sample_rate_hz: nil,
+          channels: nil,
+          codec: nil,
+          fps: nil,
+          audio_codec: nil
+        }.freeze
+
+        # Extract technical metadata from a media file.
+        # @param [String] file_path path to the media file
+        # @param [String, Symbol, nil] media_type explicit type override
+        # @return [Hash] { media_type:, media: {...}, warnings: [...] }
+        def extract(file_path, media_type: nil)
+          detected = media_type || detect_media_type(file_path)
+          return { media_type: 'other', media: DEFAULT_MEDIA.dup, warnings: [] } unless detected
+
+          type = detected.to_sym
+          media = DEFAULT_MEDIA.dup
+          warnings = []
+
+          case type
+          when :image then extract_image(file_path, media, warnings)
+          when :audio then extract_audio(file_path, media, warnings)
+          when :video then extract_video(file_path, media, warnings)
+          end
+
+          { media_type: type.to_s, media: media, warnings: warnings }
+        rescue StandardError => e
+          {
+            media_type: (type ? type.to_s : 'other'),
+            media: (defined?(media) && media) || DEFAULT_MEDIA.dup,
+            warnings: ["media metadata extraction failed: #{e.message}"]
+          }
+        end
+
+        # Detect media type from file extension.
+        # @param [String] file_path
+        # @return [Symbol, nil] :image | :audio | :video | nil (unknown)
+        def detect_media_type(file_path)
+          ext = File.extname(file_path.to_s).downcase
+          return :image if IMAGE_EXTS.include?(ext)
+          return :audio if AUDIO_EXTS.include?(ext)
+          return :video if VIDEO_EXTS.include?(ext)
+
+          nil
+        end
+
+        # Check whether the image dependency (Pillow) is available.
+        def pillow_available?
+          return @pillow_available unless @pillow_available.nil?
+
+          @pillow_available = system('python3', '-c', 'import PIL', out: File::NULL, err: File::NULL) ||
+                              system('python', '-c', 'import PIL', out: File::NULL, err: File::NULL)
+        end
+
+        # Check whether ffprobe is available.
+        def ffprobe_available?
+          return @ffprobe_available unless @ffprobe_available.nil?
+
+          @ffprobe_available = !ffprobe_cmd.nil?
+        end
+
+        private
+
+        def extract_image(file_path, media, warnings)
+          unless pillow_available?
+            warnings << 'Pillow (PIL) not available; image metadata skipped'
+            return media
+          end
+
+          python = %w[python3 python].find { |cmd| system(cmd, '-c', 'import PIL', out: File::NULL, err: File::NULL) }
+          script = <<~PYTHON
+            import json, sys
+            from PIL import Image
+
+            path = sys.argv[1]
+            img = Image.open(path)
+            info = {
+              'format': (img.format or '').lower() or None,
+              'width': img.width,
+              'height': img.height,
+              'color_mode': img.mode,
+            }
+            dpi = img.info.get('dpi')
+            info['dpi'] = round(dpi[0]) if dpi and isinstance(dpi[0], (int, float))
+            exif = {}
+            try:
+                from PIL import ExifTags
+                raw = img._getexif() if hasattr(img, '_getexif') else None
+                if raw:
+                    for k, v in raw.items():
+                        name = ExifTags.TAGS.get(k, str(k))
+                        if v is None or isinstance(v, (int, float, str)):
+                            exif[name] = v
+            except Exception:
+                pass
+            info['exif'] = exif
+            print(json.dumps(info))
+          PYTHON
+
+          output, status = Open3.capture2e(python, '-c', script, file_path)
+          unless status.success?
+            warnings << "image metadata extraction failed: #{output.strip}"
+            return media
+          end
+
+          parsed = JSON.parse(output)
+          media[:format] = parsed['format']
+          media[:width] = parsed['width']
+          media[:height] = parsed['height']
+          media[:color_mode] = parsed['color_mode']
+          media[:dpi] = parsed['dpi']
+          media[:exif] = parsed['exif'] || {}
+          media[:orientation] = derive_orientation(media[:width], media[:height])
+          media
+        rescue JSON::ParserError, SystemCallError => e
+          warnings << "image metadata extraction failed: #{e.message}"
+          media
+        end
+
+        def extract_audio(file_path, media, warnings)
+          probe = probe_ffprobe(file_path, warnings)
+          return media unless probe
+
+          format_info = probe['format'] || {}
+          stream = probe['streams'].to_a.find { |s| s['codec_type'] == 'audio' } || probe['streams'].to_a.first
+
+          media[:format] = File.extname(file_path.to_s).downcase.sub('.', '')
+          media[:codec] = stream && stream['codec_name']
+          media[:duration_ms] = ms_of(format_info['duration'])
+          media[:bitrate_bps] = int_of(format_info['bit_rate']) || (stream && int_of(stream['bit_rate']))
+          media[:sample_rate_hz] = stream && int_of(stream['sample_rate'])
+          media[:channels] = stream && int_of(stream['channels'])
+          media
+        end
+
+        def extract_video(file_path, media, warnings)
+          probe = probe_ffprobe(file_path, warnings)
+          return media unless probe
+
+          format_info = probe['format'] || {}
+          streams = probe['streams'].to_a
+          video_stream = streams.find { |s| s['codec_type'] == 'video' }
+          audio_stream = streams.find { |s| s['codec_type'] == 'audio' }
+
+          media[:format] = File.extname(file_path.to_s).downcase.sub('.', '')
+          media[:duration_ms] = ms_of(format_info['duration'])
+          media[:bitrate_bps] = int_of(format_info['bit_rate'])
+          if video_stream
+            media[:width] = int_of(video_stream['width'])
+            media[:height] = int_of(video_stream['height'])
+            media[:codec] = video_stream['codec_name']
+            media[:fps] = fps_of(video_stream)
+          end
+          media[:audio_codec] = audio_stream && audio_stream['codec_name']
+          media[:orientation] = derive_orientation(media[:width], media[:height])
+          media
+        end
+
+        def probe_ffprobe(file_path, warnings)
+          cmd = ffprobe_cmd
+          unless cmd
+            warnings << 'ffprobe not available; audio/video metadata skipped'
+            return nil
+          end
+
+          args = [cmd, '-v', 'quiet', '-print_format', 'json', '-show_format', '-show_streams', file_path]
+          output, status, = Open3.capture3(*args)
+          unless status.success?
+            warnings << "ffprobe failed: #{output.strip}"
+            return nil
+          end
+
+          JSON.parse(output)
+        rescue JSON::ParserError, SystemCallError, Errno::ENOENT => e
+          warnings << "ffprobe failed: #{e.message}"
+          nil
+        end
+
+        def ffprobe_cmd
+          @ffprobe_cmd ||= %w[ffprobe].find { |c| system('which', c, out: File::NULL, err: File::NULL) }
+        end
+
+        def ms_of(value)
+          return nil if value.nil?
+
+          (value.to_f * 1000).round
+        end
+
+        def int_of(value)
+          return nil if value.nil?
+
+          Integer(value.to_s, exception: false)
+        end
+
+        def fps_of(stream)
+          rate = stream['avg_frame_rate'].to_s
+          return nil if rate.empty?
+
+          num, den = rate.split('/')
+          return nil if num.nil?
+
+          den = '1' if den.to_s.empty? || den.to_i.zero?
+          (num.to_f / den.to_f).round(2)
+        end
+
+        def derive_orientation(width, height)
+          return nil unless width && height
+          return 'square' if width == height
+
+          width > height ? 'landscape' : 'portrait'
+        end
+      end
+    end
+  end
+end

data/lib/smart_brain/adapters/smart_rag/null_client.rb

@@ -4,7 +4,12 @@ module SmartBrain
   module Adapters
     module SmartRag
       class NullClient
+        WRITE_OPERATIONS = %i[document media image audio video].freeze
+
         def retrieve(plan)
+          business_scoped = Array(plan.dig(:scope_context, :read)).any? do |ref|
+            (ref[:type] || ref['type']).to_s != 'session'
+          end
           {
             version: '0.1',
             plan_id: "local-#{plan[:request_id]}",
@@ -12,10 +17,47 @@ module SmartBrain
             generated_at: Time.now.utc.iso8601,
             evidences: [],
             stats: { candidates: 0, returned: 0, took_ms: 0 },
-            explain: { ignored_fields: [] },
-            warnings: ['smart_rag client not configured; returned empty evidences']
+            explain: { ignored_fields: business_scoped ? ['scope_context.read'] : [] },
+            warnings: [business_scoped ? 'smart_rag scope filter unavailable: client not configured; failed closed' :
+              'smart_rag client not configured; returned empty evidences'],
+            scope_filter_applied: !business_scoped
           }
         end
+
+        WRITE_OPERATIONS.each do |type|
+          define_method("add_#{type}") do |_source, _options = {}|
+            { status: 'unsupported', media_type: type.to_s, section_count: 0,
+              warnings: ["smart_rag client not configured; add_#{type} ignored"] }
+          end
+        end
+
+        def enqueue_media(_source, _options = {})
+          { status: 'unsupported', warnings: ['smart_rag client not configured; enqueue_media ignored'] }
+        end
+
+        def media_job(job_id)
+          { status: 'unsupported', job_id: job_id, warnings: ['smart_rag client not configured; media_job ignored'] }
+        end
+
+        def media_jobs(status: nil, limit: 20, offset: 0)
+          { status: 'unsupported', jobs: [], total: 0,
+            warnings: ['smart_rag client not configured; media_jobs ignored'] }
+        end
+
+        def cancel_media_job(job_id)
+          { status: 'unsupported', job_id: job_id,
+            warnings: ['smart_rag client not configured; cancel_media_job ignored'] }
+        end
+
+        def retry_media_job(job_id)
+          { status: 'unsupported', job_id: job_id,
+            warnings: ['smart_rag client not configured; retry_media_job ignored'] }
+        end
+
+        def media_job_statistics
+          { status: 'unsupported', counts: {}, total: 0,
+            warnings: ['smart_rag client not configured; media_job_statistics ignored'] }
+        end
       end
     end
   end

data/lib/smart_brain/adapters/smart_rag/scope_filter.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module SmartBrain
+  module Adapters
+    module SmartRag
+      module ScopeFilter
+        private
+
+        def prepare_scoped_plan(plan)
+          refs = Array(plan.dig(:scope_context, :read)).reject { |ref| (ref[:type] || ref['type']).to_s == 'session' }
+          return [plan, false, [], []] if refs.empty?
+
+          unless scope_mapper
+            warning = 'smart_rag scope filter unavailable: no scope mapper configured'
+            return [nil, true, ['scope_context.read'], [warning]] if fail_closed
+            return [plan, true, ['scope_context.read'], [warning]]
+          end
+
+          mapped = scope_mapper.call(
+            domain_id: plan.dig(:debug, :caller, :domain_id),
+            scopes: refs
+          )
+          applied = mapped.fetch(:applied, true)
+          filters = mapped[:filters] || mapped.reject { |key, _value| %i[applied warnings ignored_fields].include?(key) }
+          warnings = Array(mapped[:warnings])
+          ignored = Array(mapped[:ignored_fields])
+          return [nil, true, ignored + ['scope_context.read'], warnings + ['smart_rag scope mapper did not apply filters']] if !applied && fail_closed
+
+          [plan.merge(scope_filters: filters), true, ignored, warnings]
+        rescue StandardError => e
+          warning = "smart_rag scope mapping failed: #{e.message}"
+          fail_closed ? [nil, true, ['scope_context.read'], [warning]] : [plan, true, ['scope_context.read'], [warning]]
+        end
+
+        def scope_failure_pack(plan, ignored, warnings, prefix:)
+          {
+            version: '0.2', request_id: plan[:request_id], plan_id: "#{prefix}-#{plan[:request_id]}",
+            generated_at: Time.now.utc.iso8601, evidences: [],
+            stats: { candidates: 0, returned: 0, took_ms: 0 },
+            explain: { ignored_fields: ignored }, warnings: warnings,
+            scope_filter_applied: false
+          }
+        end
+
+        def enforce_scope_confirmation(pack, required:, ignored:, warnings:)
+          confirmed = pack[:scope_filter_applied] == true
+          pack[:explain] ||= { ignored_fields: [] }
+          pack[:explain][:ignored_fields] = Array(pack.dig(:explain, :ignored_fields)) + ignored
+          pack[:warnings] = Array(pack[:warnings]) + warnings
+          return pack unless required && !confirmed
+
+          pack[:explain][:ignored_fields] << 'scope_context.read'
+          pack[:warnings] << 'smart_rag did not confirm scope filter application'
+          pack[:evidences] = [] if fail_closed
+          pack
+        end
+      end
+    end
+  end
+end

data/lib/smart_brain/configuration.rb

@@ -37,5 +37,65 @@ module SmartBrain
     def observability
       policies.fetch(:observability, {})
     end
+
+    def scopes
+      policies.fetch(:scopes, {})
+    end
+
+    def allowed_scope_types
+      scopes.fetch(:allowed_types, %w[global project expert task session]).map(&:to_s)
+    end
+
+    def storage
+      raw.fetch(:storage, {})
+    end
+
+    def llm
+      raw.fetch(:model_provider, {})
+    end
+
+    def llm_provider
+      (ENV['SMARTBRAIN_LLM_PROVIDER'] || llm.fetch(:provider, 'stub')).to_s
+    end
+
+    def tiers
+      raw.fetch(:tiers, {})
+    end
+
+    def lifecycle
+      raw.fetch(:lifecycle, {})
+    end
+
+    def kg
+      raw.fetch(:kg, {})
+    end
+
+    def fact_check
+      raw.fetch(:fact_check, {})
+    end
+
+    def briefing
+      raw.fetch(:briefing, {})
+    end
+
+    def storage_backend
+      (ENV['SMARTBRAIN_BACKEND'] || storage.fetch(:backend, 'memory')).to_s
+    end
+
+    def database_config
+      cfg = (storage.fetch(:database, {}) || {}).dup
+      %i[host port database user password].each do |key|
+        # The `database` key maps to SMARTBRAIN_DB_NAME to match the documented
+        # env contract (SMARTBRAIN_DB_{HOST,PORT,NAME,USER,PASSWORD}).
+        suffix = key == :database ? 'NAME' : key.to_s.upcase
+        env_key = "SMARTBRAIN_DB_#{suffix}"
+        cfg[key] = ENV[env_key] if ENV.key?(env_key)
+      end
+      cfg
+    end
+
+    def fts_config
+      storage.fetch(:fts_config, nil) || database_config.fetch(:fts_config, 'simple')
+    end
   end
 end

data/lib/smart_brain/consolidator/working_summary.rb

@@ -1,42 +1,103 @@
 # frozen_string_literal: true
 
+require_relative '../model_provider/stub'
+
 module SmartBrain
   module Consolidator
+    # WorkingSummary is store-backed: summaries persist via the MemoryStore
+    # (in-memory hash for MemoryStore::InMemory, the summaries table for
+    # MemoryStore::Postgres), so they survive runtime restarts on the PG path.
+    # The last-summary turn is derived from the persisted summary's source range.
+    #
+    # When a real LLM ModelProvider is wired, the summary text is generated by
+    # the model (qwen3 etc.); otherwise it falls back to the deterministic
+    # template (Stub default), so behavior is stable and offline-friendly.
     class WorkingSummary
-      def initialize(config:, clock:)
+      SUMMARY_SYSTEM = 'You are a memory consolidator. Produce a concise rolling ' \
+                       'summary in the exact section structure given. Skip empty ' \
+                       'sections. No preamble, no markdown fences.'
+
+      def initialize(config:, clock:, memory_store:, model_provider: SmartBrain::ModelProvider::Stub.new)
         @config = config
         @clock = clock
-        @summaries = {}
-        @last_summary_turn = Hash.new(0)
+        @memory_store = memory_store
+        @model_provider = model_provider
       end
 
       def update(session_id:, turn_count:, recent_turns:, memory_items:, stage_event: false)
         reason = trigger_reason(session_id: session_id, turn_count: turn_count, recent_turns: recent_turns, stage_event: stage_event)
-        return latest_summary(session_id).merge(triggered: false, trigger_reason: 'not_triggered') unless reason
+        unless reason
+          return latest_summary(session_id).merge(triggered: false, trigger_reason: 'not_triggered')
+        end
 
+        text, method = build_summary_text(memory_items: memory_items, recent_turns: recent_turns)
         summary = {
           summary_version: next_version(session_id),
           summary_source_turn_range: source_turn_range(turn_count),
           summary_generated_at: clock.call.iso8601,
-          text: build_text(memory_items),
+          text: text,
+          summary_method: method,
           triggered: true,
           trigger_reason: reason
         }
-        summaries[session_id] = summary
-        last_summary_turn[session_id] = turn_count
+        memory_store.save_summary(session_id: session_id, summary: summary)
         summary
       end
 
       def latest_summary(session_id)
-        summaries[session_id] || default_summary
+        memory_store.latest_summary(session_id: session_id) || default_summary
       end
 
       private
 
-      attr_reader :config, :clock, :summaries, :last_summary_turn
+      attr_reader :config, :clock, :memory_store, :model_provider
+
+      def build_summary_text(memory_items:, recent_turns:)
+        if model_provider&.llm?
+          text = llm_summary(memory_items: memory_items, recent_turns: recent_turns)
+          return [text, 'llm'] unless text.nil? || text.strip.empty?
+        end
+
+        [build_text(memory_items), 'template']
+      end
+
+      def llm_summary(memory_items:, recent_turns:)
+        result = model_provider.complete(
+          prompt: summary_prompt(memory_items: memory_items, recent_turns: recent_turns),
+          system: SUMMARY_SYSTEM,
+          temperature: config.llm.fetch(:temperature, 0.2),
+          max_tokens: config.llm.fetch(:summary_max_tokens, 900)
+        )
+        result[:error] ? nil : result[:text]
+      rescue StandardError
+        nil
+      end
+
+      def summary_prompt(memory_items:, recent_turns:)
+        convo = Array(recent_turns).map { |t| "#{t[:role]}: #{t[:content]}" }.join("\n")
+        mem = memory_items.group_by { |i| i[:type] }
+                          .map { |type, items| "#{type}: #{items.first(8).map { |i| i[:key] }.join(', ')}" }
+                          .join("\n")
+        <<~PROMPT
+          <conversation>
+          #{convo}
+          </conversation>
+
+          <memory>
+          #{mem}
+          </memory>
+
+          Write a concise rolling summary of the conversation above using ONLY these sections (omit a section if empty, terse bullets, cite memory keys). Do not echo the input or add preamble:
+          Goals:
+          Decisions:
+          Tasks:
+          Key References:
+          Open Questions:
+        PROMPT
+      end
 
       def trigger_reason(session_id:, turn_count:, recent_turns:, stage_event:)
-        turns_since_last = turn_count - last_summary_turn[session_id]
+        turns_since_last = turn_count - last_summary_turn(session_id)
         threshold = config.retention.fetch(:summarize_after_turns, 12)
         return 'turn_threshold' if turns_since_last >= threshold
 
@@ -48,13 +109,20 @@ module SmartBrain
         nil
       end
 
+      def last_summary_turn(session_id)
+        summary = memory_store.latest_summary(session_id: session_id)
+        return 0 unless summary
+
+        (summary[:summary_source_turn_range] || {})[:to].to_i
+      end
+
       def estimate_tokens(recent_turns)
         recent_turns.sum { |t| t[:content].to_s.length / 4 }
       end
 
       def next_version(session_id)
-        previous = summaries[session_id]
-        previous ? previous[:summary_version] + 1 : 1
+        previous = memory_store.latest_summary(session_id: session_id)
+        previous ? previous[:summary_version].to_i + 1 : 1
       end
 
       def source_turn_range(turn_count)

data/lib/smart_brain/context_composer/composer.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'securerandom'
+require_relative '../governance/tiers'
 
 module SmartBrain
   module ContextComposer
@@ -10,9 +11,10 @@ module SmartBrain
         @clock = clock
       end
 
-      def compose(session_id:, user_message:, plan:, plan_id:, summary:, recent_turns:, evidence_bundle:)
+      def compose(session_id:, user_message:, plan:, plan_id:, summary:, recent_turns:, evidence_bundle:,
+                  domain_id: 'legacy', scope_context: nil)
         context_id = SecureRandom.uuid
-        evidence = evidence_bundle.fetch(:selected, [])
+        evidence = apply_tier_order(evidence_bundle.fetch(:selected, []))
         used_estimate = estimate_tokens(summary: summary[:text], recent_turns: recent_turns, evidence: evidence, user_message: user_message)
         token_limit = config.composition.fetch(:token_limit, 8192)
 
@@ -20,6 +22,8 @@ module SmartBrain
           version: '0.1',
           context_id: context_id,
           session_id: session_id,
+          domain_id: domain_id,
+          scope_context: scope_context,
           created_at: clock.call.iso8601,
           system_blocks: [],
           developer_blocks: [],
@@ -54,7 +58,14 @@ module SmartBrain
             },
             why_selected: evidence.map { |e| "#{e[:id]} score=#{e[:score]} source=#{e[:source]}" },
             ignored: evidence_bundle[:ignored_fields] || [],
-            dropped: (evidence_bundle[:dropped] || []).map { |e| { id: e[:id], reason: e[:drop_reason] } }
+            dropped: (evidence_bundle[:dropped] || []).map { |e| { id: e[:id], reason: e[:drop_reason] } },
+            scopes_read: Array(scope_context && scope_context[:read]),
+            scope_stats: evidence_bundle[:scope_stats] || {},
+            shadowed: (evidence_bundle[:shadowed] || []).map do |e|
+              e.slice(:id, :memory_type, :memory_key, :scope, :shadow_reason, :shadowed_by)
+            end,
+            scope_budget: evidence_bundle[:scope_budget] || {},
+            scope_filter_warnings: evidence_bundle[:scope_filter_warnings] || []
           }
         }
       end
@@ -70,6 +81,32 @@ module SmartBrain
         text_size += user_message.to_s.length
         (text_size / 4.0).ceil
       end
+
+      # Order evidence by mind-model tier (dao_tian → dao_ren → shu → qi →
+      # evidence), preserving score order within a tier, and cap immutable
+      # dao_tian principles at dao_tian_limit.
+      def apply_tier_order(evidence)
+        dao_tian_limit = begin
+                           Governance::Tiers.dao_tian_limit(config)
+                         rescue StandardError
+                           1
+                         end
+        stable = evidence.each_with_index
+        sorted = stable.sort_by do |e, idx|
+          [Governance::Tiers.priority(e[:tier] || 'evidence'), -(e[:score] || 0.0), idx]
+        end
+        result = []
+        dao_tian_count = 0
+        sorted.each do |e, _idx|
+          if (e[:tier] || 'evidence') == 'dao_tian'
+            next if dao_tian_count >= dao_tian_limit
+
+            dao_tian_count += 1
+          end
+          result << e
+        end
+        result
+      end
     end
   end
 end

data/lib/smart_brain/contracts/retrieval_plan.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'scope_context'
+
 module SmartBrain
   module Contracts
     class RetrievalPlan
@@ -10,6 +12,14 @@ module SmartBrain
         raise ArgumentError, "invalid retrieval plan: missing #{missing.join(', ')}" unless missing.empty?
         raise ArgumentError, 'invalid retrieval plan: queries must not be empty' if Array(plan[:queries]).empty?
 
+        if plan[:scope_context]
+          ScopeContext.normalize(
+            domain_id: plan.dig(:debug, :caller, :domain_id),
+            session_id: plan.dig(:debug, :caller, :session_id) || plan[:session_id],
+            scope_context: plan[:scope_context]
+          )
+        end
+
         true
       end
     end