woods 2.0.0.beta1 → 2.0.0.beta3

data/lib/woods/retriever.rb

@@ -8,6 +8,11 @@ require_relative 'retrieval/query_classifier'
 require_relative 'retrieval/search_executor'
 require_relative 'retrieval/ranker'
 require_relative 'retrieval/context_assembler'
+require_relative 'retrieval/lexical_index'
+require_relative 'retrieval/lexical_assembler'
+require_relative 'retrieval/scope'
+require_relative 'retrieval/scoped_vector_store'
+require_relative 'retrieval/scoped_graph_store'
 require_relative 'embedding/token_counter'
 require_relative 'token_utils'
 
@@ -59,6 +64,7 @@ module Woods
     ).freeze
 
     # Diagnostic trace for retrieval quality analysis.
+    # +tokens_used+ counts the final delivered context, including postprocessing.
     #
     # +skipped_missing_metadata+ carries {Retrieval::ContextAssembler}'s count
     # of candidates dropped because the metadata store had no record for
@@ -98,7 +104,7 @@ module Woods
     #
     # Nil for unfiltered queries.
     RetrievalResult = Struct.new(:context, :sources, :classification, :strategy, :tokens_used, :budget, :trace,
-                                 :type_rank_context, keyword_init: true)
+                                 :type_rank_context, :applied_scope, keyword_init: true)
 
     # Raised when a metadata-store access fails during retrieval (M8). One
     # shared typed error for every store call site: the retriever used to
@@ -191,7 +197,7 @@ module Woods
     # The reload transaction swaps the whole struct via {#swap_stores!}.
     #
     # @return [Pipeline]
-    attr_reader :pipeline
+    attr_reader :pipeline, :mode, :default_budget
 
     # Optional callback invoked with the pipeline struct the moment
     # {#retrieve} resolves it, before any pipeline work runs. Nil in
@@ -207,7 +213,13 @@ module Woods
     # @param graph_store [Storage::GraphStore::Interface] Graph store adapter
     # @param embedding_provider [Embedding::Provider::Interface] Embedding provider
     # @param formatter [#call, nil] Optional callable to post-process the context string
-    def initialize(vector_store:, metadata_store:, graph_store:, embedding_provider:, formatter: nil)
+    # @param default_budget [Integer] Token budget when retrieve omits budget
+    def initialize(vector_store:, metadata_store:, graph_store:, embedding_provider:, formatter: nil, mode: :semantic,
+                   default_budget: 8000)
+      raise ArgumentError, 'unknown retrieval mode' unless %i[semantic lexical].include?(mode)
+
+      @mode = mode
+      @default_budget = default_budget
       @embedding_provider = embedding_provider
       @formatter = formatter
       @classifier = Retrieval::QueryClassifier.new
@@ -246,7 +258,9 @@ module Woods
     # they make raises the typed {StoreError} instead of a raw adapter error
     # (MCP-6); the struct keeps the raw adapters for identity and capability
     # checks.
-    def build_pipeline(vector_store:, metadata_store:, graph_store:)
+    def build_pipeline(vector_store:, metadata_store:, graph_store:) # rubocop:disable Metrics/MethodLength
+      return build_lexical_pipeline(metadata_store, graph_store) if @mode == :lexical
+
       translated_vector = translate_store(vector_store, :vector)
       translated_metadata = translate_store(metadata_store, :metadata)
       translated_graph = translate_store(graph_store, :graph)
@@ -269,6 +283,14 @@ module Woods
         graph_store: graph_store
       )
     end
+
+    def build_lexical_pipeline(metadata_store, graph_store)
+      executor = Retrieval::LexicalIndex.new(metadata_store: translate_store(metadata_store, :metadata))
+      Pipeline.new(executor: executor, assembler: Retrieval::LexicalAssembler.new, metadata_store: metadata_store,
+                   vector_store: nil, graph_store: graph_store)
+    end
+    private :build_lexical_pipeline
+
     private :build_pipeline
 
     # Wrap one store adapter for the pipeline components. Nil stays nil — a
@@ -357,16 +379,29 @@ module Woods
     #   unit types (overrides DEFAULT_EXCLUDE_TYPES).
     # @param exclude_types [Array<String, Symbol>, nil] Additional types to
     #   exclude. Applied on top of DEFAULT_EXCLUDE_TYPES unless +types:+ is set.
-    # @return [RetrievalResult] Complete retrieval result
-    def retrieve(query, budget: 8000, types: nil, exclude_types: nil)
+    # @param packages [Array<String>, nil] Exact published nearest package owners
+    # @param source_paths [Array<String>, nil] Application-relative directory prefixes
+    # @return [RetrievalResult] Complete retrieval result; scoped calls carry applied_scope
+    def retrieve(query, budget: @default_budget, types: nil, exclude_types: nil, packages: nil, source_paths: nil,
+                 evidence: 'full', evidence_generation: nil) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       validate_query!(query)
+      Retrieval::SourceEvidence.validate_mode!(evidence)
+      evidence_options = evidence == 'full' ? {} : { evidence: evidence, query: query, generation: evidence_generation }
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       # One atomic read of the bundle reference: everything this query does
       # from here on — execution, ranking, filtering, assembly — stays on the
       # SAME store set even if a reload swaps the pipeline mid-flight (M7).
       pipeline = @pipeline
       @pipeline_observer&.call(pipeline)
+      scope = resolve_scope(pipeline, packages, source_paths, types, exclude_types)
+      pipeline = scoped_pipeline(pipeline, scope) if scope
       classification = @classifier.classify(query)
+      if @mode == :lexical
+        result = retrieve_lexical(pipeline, query, classification, budget, types, exclude_types, start_time,
+                                  **evidence_options)
+        return attach_scope(result, scope)
+      end
+
       execution_result = pipeline.executor.execute(query: query, classification: classification)
       ranked = pipeline.ranker.rank(execution_result.candidates, classification: classification)
 
@@ -374,20 +409,61 @@ module Woods
       filtered, fallback_ran = apply_type_filter(pipeline, ranked, query, classification,
                                                  types: types, type_list: type_list,
                                                  exclude_types: exclude_types)
-      type_rank_context = build_type_rank_context_for(ranked, pipeline, type_list, filtered,
-                                                      fallback_ran: fallback_ran)
-
-      assembled = assemble_context(pipeline, filtered, classification, budget)
-      trace = build_trace(classification, execution_result, filtered, assembled, start_time)
+      type_rank_context = unless scope
+                            build_type_rank_context_for(ranked, pipeline, type_list, filtered,
+                                                        fallback_ran: fallback_ran)
+                          end
 
+      assembled = assemble_context(pipeline, filtered, classification, budget, **evidence_options)
       build_result(
-        assembled: assembled, classification: classification, strategy: execution_result.strategy,
-        budget: budget, trace: trace, type_rank_context: type_rank_context
-      )
+        assembled: assembled, assembler: pipeline.assembler, classification: classification,
+        strategy: execution_result.strategy, budget: budget, type_rank_context: type_rank_context
+      ).tap do |result|
+        result.trace = build_trace(result, execution_result, filtered, assembled, start_time)
+        attach_scope(result, scope)
+      end
     end
 
     private
 
+    def resolve_scope(pipeline, packages, source_paths, types, excluded)
+      return unless Retrieval::Scope.requested?(packages: packages, source_paths: source_paths)
+
+      Retrieval::Scope.new(metadata_store: translate_store(pipeline.metadata_store, :metadata),
+                           packages: packages, source_paths: source_paths, types: types,
+                           exclude_types: DEFAULT_EXCLUDE_TYPES + Array(excluded).map(&:to_s))
+    end
+
+    def scoped_pipeline(pipeline, scope)
+      vector = Retrieval::ScopedVectorStore.new(store: pipeline.vector_store, scope: scope)
+      graph = Retrieval::ScopedGraphStore.new(store: pipeline.graph_store, scope: scope)
+      build_pipeline(vector_store: vector, metadata_store: scope.metadata_store, graph_store: graph)
+    end
+
+    def attach_scope(result, scope)
+      return result unless scope
+
+      result.applied_scope = scope.summary.merge(
+        outcome: if scope.keys.empty?
+                   :empty_scope
+                 else
+                   (result.trace.ranked_count.zero? ? :no_match : :matched)
+                 end,
+        candidate_count: result.trace.candidate_count, returned_units: result.sources.size
+      )
+      result
+    end
+
+    def retrieve_lexical(pipeline, query, classification, budget, types, exclude_types, start_time, **evidence_options)
+      excluded = DEFAULT_EXCLUDE_TYPES + Array(exclude_types).map(&:to_s)
+      execution = pipeline.executor.execute(query: query, type_filter: types, exclude_types: excluded)
+      assembled = pipeline.assembler.assemble(candidates: execution.candidates, budget: budget, **evidence_options)
+      result = build_result(assembled: assembled, assembler: pipeline.assembler, classification: classification,
+                            strategy: :lexical, budget: budget)
+      result.trace = build_trace(result, execution, execution.candidates, assembled, start_time)
+      result
+    end
+
     # Validate +query+ before any classify/execute/rank work happens.
     #
     # @param query [Object] The caller-supplied query
@@ -464,23 +540,24 @@ module Woods
     # @param ranked [Array<Candidate>] Ranked search candidates
     # @param classification [QueryClassifier::Classification] Query classification
     # @return [AssembledContext]
-    def assemble_context(pipeline, ranked, classification, budget)
+    def assemble_context(pipeline, ranked, classification, budget, **evidence_options)
       pipeline.assembler.assemble(
         candidates: ranked,
         classification: classification,
         structural_context: build_structural_context(pipeline.metadata_store),
-        budget: budget
+        budget: budget, **evidence_options
       )
     end
 
     # Build a RetrievalResult from assembled context and pipeline metadata.
     #
     # @param assembled [AssembledContext] Assembled context
+    # @param assembler [Retrieval::ContextAssembler] Counter configuration used for assembly
     # @param classification [QueryClassifier::Classification] Query classification
     # @param strategy [Symbol] Search strategy used
     # @param budget [Integer] Token budget
     # @return [RetrievalResult]
-    def build_result(assembled:, classification:, strategy:, budget:, trace: nil, type_rank_context: nil)
+    def build_result(assembled:, assembler:, classification:, strategy:, budget:, type_rank_context: nil)
       context = @formatter ? @formatter.call(assembled.context) : assembled.context
       context = append_type_rank_context(context, type_rank_context) if type_rank_context
 
@@ -489,9 +566,8 @@ module Woods
         sources: assembled.sources,
         classification: classification,
         strategy: strategy,
-        tokens_used: assembled.tokens_used,
+        tokens_used: assembler.estimate_tokens(context),
         budget: budget,
-        trace: trace,
         type_rank_context: type_rank_context
       )
     end
@@ -534,14 +610,14 @@ module Woods
       filter_by_type(pipeline, ranked, types: type_array, exclude_types: exclude_types)
     end
 
-    def build_trace(classification, execution_result, filtered, assembled, start_time)
+    def build_trace(result, execution_result, filtered, assembled, start_time)
       elapsed_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(1)
       RetrievalTrace.new(
-        classification: classification,
+        classification: result.classification,
         strategy: execution_result.strategy,
         candidate_count: execution_result.candidates.size,
         ranked_count: filtered.size,
-        tokens_used: assembled.tokens_used,
+        tokens_used: result.tokens_used,
         elapsed_ms: elapsed_ms,
         skipped_missing_metadata: assembled.skipped_missing_metadata.to_i
       )

data/lib/woods/ruby_analyzer/trace_enricher.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'fiber'
+
 require_relative '../extracted_unit'
 
 module Woods
@@ -19,25 +21,26 @@ module Woods
     class TraceEnricher
       # Record method calls during block execution using TracePoint.
       #
+      # Records the current thread only, with independent stacks for its fibers.
+      # Caller fields identify the nearest observed Ruby method, not native or
+      # block frames. Calls entered before recording have an unknown caller.
+      #
       # @yield Block to trace
       # @return [Array<Hash>] Collected trace events
+      # @raise [ArgumentError] if no block is given
       def self.record(&block)
-        traces = []
+        raise ArgumentError, 'block required' unless block
 
+        traces = []
+        stacks = Hash.new { |frames, fiber| frames[fiber] = [] }
         trace = TracePoint.new(:call, :return) do |tp|
-          traces << {
-            class_name: tp.defined_class&.name || tp.defined_class.to_s,
-            method_name: tp.method_id.to_s,
-            event: tp.event.to_s,
-            path: tp.path,
-            line: tp.lineno,
-            caller_class: extract_caller_class(tp),
-            caller_method: extract_caller_method(tp),
-            return_class: tp.event == :return ? safe_return_class(tp) : nil
-          }
+          fiber = Fiber.current
+          stack = stacks[fiber]
+          traces << record_event(tp, stack)
+          stacks.delete(fiber) if stack.empty?
         end
 
-        trace.enable(&block)
+        trace.enable(target_thread: Thread.current, &block)
         traces
       end
 
@@ -52,14 +55,11 @@ module Woods
       def self.merge(units:, trace_data:)
         return units if trace_data.nil? || trace_data.empty?
 
-        # Index traces by class_name + method_name
+        # Index by defining owner, method name, and instance/singleton kind.
         grouped = group_traces(trace_data)
 
         units.each do |unit|
-          class_name, method_name = parse_identifier(unit.identifier)
-          next unless class_name && method_name
-
-          key = "#{class_name}##{method_name}"
+          key = parse_identifier(unit.identifier)
           next unless grouped.key?(key)
 
           traces = grouped[key]
@@ -72,7 +72,10 @@ module Woods
             caller_method = fetch_key(t, :caller_method)
             next unless caller_class
 
-            { 'caller_class' => caller_class, 'caller_method' => caller_method }
+            caller = { 'caller_class' => caller_class, 'caller_method' => caller_method }
+            kind = fetch_key(t, :caller_method_kind)
+            caller['caller_method_kind'] = kind.to_s if kind
+            caller
           end
 
           return_types = returns.filter_map do |t|
@@ -101,35 +104,74 @@ module Woods
             method_name = fetch_key(trace, :method_name)
             next unless class_name && method_name
 
-            key = "#{class_name}##{method_name}"
-            grouped[key] << trace
+            # Legacy recorder output with a named owner describes instance
+            # methods. Never infer its kind from the units supplied to merge.
+            kind = (fetch_key(trace, :method_kind) || 'instance').to_s
+            next unless %w[instance singleton].include?(kind)
+            next if class_name.start_with?('#<')
+
+            grouped[[class_name, method_name, kind]] << trace
           end
           grouped
         end
 
         def parse_identifier(identifier)
-          # Handle both "Class#method" and "Class.method" formats
-          if identifier.include?('#')
-            identifier.split('#', 2)
-          elsif identifier.include?('.')
-            identifier.split('.', 2)
-          end
+          match = /\A(.+?)([#.])(.+)\z/.match(identifier)
+          return unless match
+
+          [match[1], match[3], match[2] == '#' ? 'instance' : 'singleton']
         end
 
-        def extract_caller_class(tp)
-          binding_obj = tp.binding
-          receiver = binding_obj.receiver
-          receiver.is_a?(Class) || receiver.is_a?(Module) ? receiver.name : receiver.class.name
-        rescue StandardError
-          nil
+        def event_identity(tp)
+          owner = tp.defined_class
+          singleton = owner&.singleton_class?
+          name = singleton ? singleton_owner_name(owner, tp.self) : owner&.name
+          { class_name: name, method_name: tp.method_id.to_s,
+            method_kind: singleton ? 'singleton' : 'instance' }
         end
 
-        def extract_caller_method(_tp)
-          # TracePoint doesn't directly expose caller method,
-          # but we can get it from the call stack
-          caller_locations(3, 1)&.first&.label
-        rescue StandardError
-          nil
+        # Ruby 3.0 has no Class#attached_object. Find the defining owner,
+        # not just the receiver: Child.run may be defined on Parent's singleton
+        # class. Singleton methods on individual objects have no named unit.
+        def singleton_owner_name(owner, receiver)
+          return unless receiver.is_a?(Module)
+
+          receiver.ancestors.find { |ancestor| ancestor.singleton_class.equal?(owner) }&.name
+        end
+
+        def record_event(tp, stack)
+          identity = event_identity(tp)
+          caller = if tp.event == :call
+                     caller_fields(stack.last)
+                   else
+                     returning_caller(identity, stack)
+                   end
+          event = identity.merge(
+            event: tp.event.to_s, path: tp.path, line: tp.lineno,
+            **caller, return_class: tp.event == :return ? safe_return_class(tp) : nil
+          )
+          stack << event if tp.event == :call
+          event
+        end
+
+        def caller_fields(frame)
+          frame = nil unless frame && frame[:class_name]
+          { caller_class: frame && frame[:class_name], caller_method: frame && frame[:method_name],
+            caller_method_kind: frame && frame[:method_kind] }
+        end
+
+        # Ruby emits :return during exceptional and nonlocal unwinds too. A
+        # return whose call predates recording has no known caller; discard an
+        # inconsistent stack instead of inventing an edge from unrelated frames.
+        def returning_caller(identity, stack)
+          frame = stack.pop
+          if frame && identity.all? { |key, value| frame[key] == value }
+            { caller_class: frame[:caller_class], caller_method: frame[:caller_method],
+              caller_method_kind: frame[:caller_method_kind] }
+          else
+            stack.clear
+            caller_fields(nil)
+          end
         end
 
         def safe_return_class(tp)

data/lib/woods/session_tracer/middleware.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
 require 'time'
+require 'active_support/inflector'
 
 module Woods
   module SessionTracer
     # Rack middleware that captures request metadata for session tracing.
     #
     # Wraps `@app.call(env)`, records after response. Extracts controller/action
-    # from `env['action_dispatch.request.path_parameters']`. Session ID from
+    # from the dispatched controller instance and Rails path parameters. Session ID from
     # `X-Trace-Session` header first, falls back to `request.session.id`.
     #
     # Fire-and-forget writes — `rescue StandardError` on recording, never breaks the request.
@@ -98,8 +99,7 @@ module Woods
         action = path_params[:action]
         return unless controller
 
-        # Classify controller name (e.g., "orders" -> "OrdersController")
-        controller_class = classify_controller(controller)
+        controller_class = controller_identity(env['action_controller.instance'], controller)
 
         request_data = {
           'session_id' => session_id,
@@ -144,15 +144,13 @@ module Woods
         @exclude_paths.any? { |prefix| path.start_with?(prefix) }
       end
 
-      # Classify a Rails controller path segment into a controller class name.
-      #
-      # @param controller [String] e.g., "orders" or "admin/orders"
-      # @return [String] e.g., "OrdersController" or "Admin::OrdersController"
-      def classify_controller(controller)
-        parts = controller.to_s
-                          .split('/')
-                          .map { |segment| segment.split('_').map(&:capitalize).join }
-        "#{parts.join('::')}Controller"
+      # Runtime identity is authoritative. Rack adapters without a dispatched
+      # instance still use Rails' configured acronyms when classifying the route.
+      def controller_identity(instance, controller)
+        name = instance.class.name if instance
+        return name if name && !name.empty?
+
+        "#{ActiveSupport::Inflector.camelize(controller.to_s)}Controller"
       end
 
       # Extract response format from the Rack env.

data/lib/woods/session_tracer/redis_store.rb

@@ -56,6 +56,19 @@ module Woods
         return 1
       LUA
 
+      # Read and remove against either index format without converting a
+      # legacy SET. Each type check and operation is atomic with respect to
+      # a concurrent record's migration. Reader-only upgrades therefore do
+      # not prevent older SET writers from continuing to record.
+      INDEX_ACCESS_SCRIPT = <<~LUA
+        local legacy = redis.call('TYPE', KEYS[1]).ok == 'set'
+        if ARGV[1] == 'members' then
+          if legacy then return redis.call('SMEMBERS', KEYS[1]) end
+          return redis.call('ZRANGE', KEYS[1], 0, -1)
+        end
+        return redis.call(legacy and 'SREM' or 'ZREM', KEYS[1], ARGV[2])
+      LUA
+
       # @param redis [Redis] A Redis client instance
       # @param ttl [Integer, nil] Time-to-live in seconds for session keys (nil = no expiry)
       def initialize(redis:, ttl: nil, max_sessions: DEFAULT_MAX_SESSIONS,
@@ -103,14 +116,13 @@ module Woods
       # @param limit [Integer] Maximum number of sessions to return
       # @return [Array<Hash>] Session summaries
       def sessions(limit: 20)
-        all_ids = @redis.zrange(SESSIONS_KEY, 0, -1)
+        all_ids = index_access('members')
 
         # Filter to sessions that still have data (TTL may have expired)
         active = all_ids.select { |id| @redis.exists?(session_key(id)) }
 
         # Remove expired session IDs from the index
-        expired = all_ids - active
-        expired.each { |id| @redis.zrem(SESSIONS_KEY, id) } if expired.any?
+        (all_ids - active).each { |id| index_access('remove', id) }
 
         # Redis sorted sets order by score, but a summary's last_request is
         # the payload timestamp of the session's last record — the same
@@ -133,20 +145,24 @@ module Woods
       # @return [void]
       def clear(session_id)
         @redis.del(session_key(session_id))
-        @redis.zrem(SESSIONS_KEY, session_id)
+        index_access('remove', session_id)
       end
 
       # Remove all session data.
       #
       # @return [void]
       def clear_all
-        all_ids = @redis.zrange(SESSIONS_KEY, 0, -1)
+        all_ids = index_access('members')
         all_ids.each { |id| @redis.del(session_key(id)) }
         @redis.del(SESSIONS_KEY)
       end
 
       private
 
+      def index_access(action, session_id = nil)
+        @redis.eval(INDEX_ACCESS_SCRIPT, keys: [SESSIONS_KEY], argv: [action, *session_id])
+      end
+
       # @param session_id [String]
       # @return [String] Redis key for this session
       def session_key(session_id)
@@ -196,7 +212,7 @@ module Woods
 
         victims.each do |id|
           @redis.del(session_key(id))
-          @redis.zrem(SESSIONS_KEY, id)
+          index_access('remove', id)
         end
       end
 

data/lib/woods/session_tracer/session_flow_assembler.rb

@@ -4,6 +4,7 @@ require 'json'
 require 'set'
 require_relative '../token_utils'
 require_relative 'session_flow_document'
+require_relative 'unit_resolver'
 
 module Woods
   module SessionTracer
@@ -42,8 +43,14 @@ module Woods
       # @param budget [Integer] Maximum token budget (default: 8000)
       # @param depth [Integer] Expansion depth (0=metadata only, 1=direct deps, 2+=full flow)
       # @return [SessionFlowDocument] The assembled document
-      # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
       def assemble(session_id, budget: 8000, depth: 1)
+        @reader.with_pinned_generation { assemble_pinned(session_id, budget: budget, depth: depth) }
+      end
+
+      private
+
+      # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      def assemble_pinned(session_id, budget:, depth:)
         requests = @store.read(session_id)
         return empty_document(session_id) if requests.empty?
 
@@ -52,6 +59,7 @@ module Woods
         side_effects = []
         dependency_map = {}
         seen_units = Set.new
+        resolver = UnitResolver.new(@reader)
 
         requests.each_with_index do |req, idx|
           step = build_step(req, idx)
@@ -63,18 +71,17 @@ module Woods
           next unless controller_id
 
           # Resolve controller unit
-          unit = @reader.find_unit(controller_id)
+          unit = @reader.find_unit(controller_id, type: 'controller')
           if unit && !seen_units.include?(controller_id)
             seen_units.add(controller_id)
             context_pool[controller_id] = unit_summary(unit)
           end
-          step[:unit_refs] = [controller_id].compact
-
-          # Expand dependencies
+          # Expand dependencies only for a resolved controller.
           next unless unit
 
+          step[:unit_refs] = [controller_id]
           deps = resolve_dependencies(controller_id, seen_units, context_pool,
-                                      side_effects, step, dependency_map, depth)
+                                      side_effects, step, dependency_map, depth, resolver)
           step[:unit_refs].concat(deps)
         end
 
@@ -85,8 +92,6 @@ module Woods
         budgeted_document(parts, budget)
       end
 
-      private
-
       # Build a timeline step from a request record.
       #
       # @param req [Hash] Request data from store
@@ -111,13 +116,13 @@ module Woods
       # @return [Array<String>] Non-async dependency identifiers added
       # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/ParameterLists, Metrics/PerceivedComplexity
       def resolve_dependencies(unit_id, seen_units, context_pool,
-                               side_effects, step, dependency_map, depth)
+                               side_effects, step, dependency_map, depth, resolver)
         graph = @reader.dependency_graph
-        dep_ids = graph.dependencies_of(unit_id)
+        dep_ids = graph.dependencies_of(unit_id, type: :controller)
         added = []
 
         dep_ids.each do |dep_id|
-          dep_unit = @reader.find_unit(dep_id)
+          dep_unit = resolver.find(dep_id)
           next unless dep_unit
 
           dep_type = dep_unit['type']&.to_s
@@ -137,13 +142,13 @@ module Woods
               added << dep_id
 
               # Depth 2+: expand transitive dependencies
-              expand_transitive(dep_id, seen_units, context_pool, dependency_map, depth - 1) if depth >= 2
+              expand_transitive(dep_id, seen_units, context_pool, dependency_map, depth - 1, resolver) if depth >= 2
             end
           end
         end
 
         # Record dependency map for this unit
-        all_deps = dep_ids.select { |id| @reader.find_unit(id) }
+        all_deps = dep_ids.select { |id| resolver.find(id) }
         dependency_map[unit_id] = all_deps if all_deps.any?
 
         added
@@ -156,15 +161,16 @@ module Woods
       # @param context_pool [Hash] Accumulator for unit data
       # @param dependency_map [Hash] Accumulator for dependency edges
       # @param remaining_depth [Integer] Remaining expansion depth
-      def expand_transitive(unit_id, seen_units, context_pool, dependency_map, remaining_depth)
+      # rubocop:disable-next Metrics/ParameterLists
+      def expand_transitive(unit_id, seen_units, context_pool, dependency_map, remaining_depth, resolver)
         return if remaining_depth <= 0
 
         graph = @reader.dependency_graph
-        dep_ids = graph.dependencies_of(unit_id)
+        dep_ids = graph.dependencies_of(unit_id, type: resolver.find(unit_id).fetch('type').to_sym)
         resolved_deps = []
 
         dep_ids.each do |dep_id|
-          dep_unit = @reader.find_unit(dep_id)
+          dep_unit = resolver.find(dep_id)
           next unless dep_unit
 
           resolved_deps << dep_id
@@ -173,7 +179,7 @@ module Woods
           seen_units.add(dep_id)
           context_pool[dep_id] = unit_summary(dep_unit)
 
-          expand_transitive(dep_id, seen_units, context_pool, dependency_map, remaining_depth - 1)
+          expand_transitive(dep_id, seen_units, context_pool, dependency_map, remaining_depth - 1, resolver)
         end
 
         dependency_map[unit_id] = resolved_deps if resolved_deps.any?

data/lib/woods/session_tracer/solid_cache_coordination.rb

@@ -157,11 +157,13 @@ module Woods
       end
 
       def inserted?(entry_class, result, key, payload)
-        affected_rows = result.affected_rows if result.respond_to?(:affected_rows)
-        return affected_rows.positive? unless affected_rows.nil?
-        return result.rows.any? if entry_class.connection.supports_insert_returning?
+        # MySQL's FOUND_ROWS can count a duplicate no-op as an affected row.
+        # The per-attempt CAS version makes equal values distinct payloads, so
+        # only our exact stored bytes establish ownership without RETURNING.
+        return entry_class.read(key) == payload unless entry_class.connection.supports_insert_returning?
 
-        entry_class.read(key) == payload
+        affected_rows = result.affected_rows if result.respond_to?(:affected_rows)
+        affected_rows.nil? ? result.rows.any? : affected_rows.positive?
       end
 
       def routed_read(key, failsafe)