woods 2.0.0.beta1 → 2.0.0.beta3

data/lib/woods/builder.rb

@@ -110,6 +110,11 @@ module Woods
     #   on disk and passes the populated store here.
     # @return [Retriever, Cache::CachedRetriever] A fully wired retriever
     def build_retriever(vector_store: nil, metadata_store: nil, graph_store: nil)
+      if @config.retrieval_mode == :lexical
+        return build_lexical_retriever(metadata_store: metadata_store,
+                                       graph_store: graph_store)
+      end
+
       provider = build_resilient_embedding_provider
       cache = build_cache_store
 
@@ -119,12 +124,21 @@ module Woods
         vector_store: vector_store || build_vector_store(dimensions: vector_dimensions(provider)),
         metadata_store: metadata_store || build_metadata_store,
         graph_store: graph_store || build_graph_store,
-        embedding_provider: provider
+        embedding_provider: provider, default_budget: @config.max_context_tokens
       )
 
       cache ? wrap_with_retriever_cache(retriever, cache) : retriever
     end
 
+    def build_lexical_retriever(metadata_store:, graph_store:)
+      retriever = Retriever.new(vector_store: nil, metadata_store: metadata_store || build_metadata_store,
+                                graph_store: graph_store, embedding_provider: nil, mode: :lexical,
+                                default_budget: @config.max_context_tokens)
+      cache = build_cache_store
+      cache ? wrap_with_retriever_cache(retriever, cache) : retriever
+    end
+    private :build_lexical_retriever
+
     # Instantiate the vector store adapter specified by the configuration.
     #
     # The :pgvector branch also ensures the adapter's own schema exists —
@@ -482,19 +496,21 @@ module Woods
 
     # Instantiate the metadata store adapter specified by the configuration.
     #
+    # @param output_dir [String, Pathname] Default SQLite database directory; an
+    #   explicit metadata_store_options[:database] still takes precedence.
     # @return [Storage::MetadataStore::Interface] Metadata store adapter instance
     # @raise [ArgumentError] if the configured type is not recognized
-    def build_metadata_store
+    def build_metadata_store(output_dir: @config.output_dir)
       case @config.metadata_store
       when :in_memory then Storage::MetadataStore::InMemory.new
-      when :sqlite then Storage::MetadataStore::SQLite.new(**sqlite_metadata_options)
+      when :sqlite then Storage::MetadataStore::SQLite.new(**sqlite_metadata_options(output_dir))
       else raise ArgumentError, "Unknown metadata_store: #{@config.metadata_store}"
       end
     end
 
-    def sqlite_metadata_options
+    def sqlite_metadata_options(output_dir)
       opts = (@config.metadata_store_options || {}).transform_keys(&:to_sym)
-      opts[:database] ||= File.join(@config.output_dir.to_s, 'metadata.sqlite3')
+      opts[:database] ||= File.join(output_dir.to_s, 'metadata.sqlite3')
       opts
     end
     private :sqlite_metadata_options

data/lib/woods/cache/cache_middleware.rb

@@ -418,6 +418,8 @@ module Woods
       def vector_store   = @retriever.vector_store
       def metadata_store = @retriever.metadata_store
       def graph_store    = @retriever.graph_store
+      def mode = @retriever.respond_to?(:mode) ? @retriever.mode : :semantic
+      def default_budget = @retriever.respond_to?(:default_budget) ? @retriever.default_budget : 8000
 
       # Invalidate every cached context result. Called from the MCP +reload+
       # tool after the retriever's stores have been re-hydrated from a fresh
@@ -449,12 +451,17 @@ module Woods
       # @param types [Array<String, Symbol>, nil] Include-only filter
       # @param exclude_types [Array<String, Symbol>, nil] Additional exclusions
       # @return [Retriever::RetrievalResult]
-      def retrieve(query, budget: 8000, types: nil, exclude_types: nil)
-        key = context_key(query, budget, types: types, exclude_types: exclude_types)
+      def retrieve(query, budget: default_budget, types: nil, exclude_types: nil, packages: nil, source_paths: nil,
+                   evidence: 'full') # rubocop:disable Metrics/ParameterLists
+        Retrieval::SourceEvidence.validate_mode!(evidence)
+        scoped = Retrieval::Scope.requested?(packages: packages, source_paths: source_paths)
+        scope_options = scoped ? { packages: packages, source_paths: source_paths } : {}
+        scope_options[:evidence] = evidence unless evidence == 'full'
+        key = context_key(query, budget, types: types, exclude_types: exclude_types, **scope_options)
         cached = @cache_store.read(key)
         return rehydrate_cached(cached, budget) if cached
 
-        result = @retriever.retrieve(query, budget: budget, types: types, exclude_types: exclude_types)
+        result = @retriever.retrieve(query, budget: budget, types: types, exclude_types: exclude_types, **scope_options)
 
         begin
           @cache_store.write(key, serialize_result(result), ttl: @context_ttl)
@@ -478,8 +485,14 @@ module Woods
       # @param types [Array<String, Symbol>, nil]
       # @param exclude_types [Array<String, Symbol>, nil]
       # @return [String]
-      def context_key(query, budget, types: nil, exclude_types: nil)
-        Cache.cache_key(:context, query, budget.to_s, fingerprint(types), fingerprint(exclude_types))
+      def context_key(query, budget, types: nil, exclude_types: nil, packages: nil, source_paths: nil, evidence: 'full') # rubocop:disable Metrics/ParameterLists
+        parts = [query, budget.to_s, fingerprint(types), fingerprint(exclude_types)]
+        parts << 'lexical' if mode == :lexical
+        parts << JSON.generate(evidence: evidence) unless evidence == 'full'
+        if Retrieval::Scope.requested?(packages: packages, source_paths: source_paths)
+          parts << JSON.generate(packages: packages, source_paths: source_paths)
+        end
+        Cache.cache_key(:context, *parts)
       end
 
       def fingerprint(types)
@@ -504,7 +517,8 @@ module Woods
           tokens_used: cached['tokens_used'],
           budget: budget,
           trace: nil,
-          type_rank_context: rehydrate_type_rank_context(cached['type_rank_context'])
+          type_rank_context: rehydrate_type_rank_context(cached['type_rank_context']),
+          applied_scope: rehydrate_scope(cached['applied_scope'])
         )
       end
 
@@ -514,10 +528,17 @@ module Woods
           'sources' => result.sources,
           'strategy' => result.strategy&.to_s,
           'tokens_used' => result.tokens_used,
-          'type_rank_context' => serialize_type_rank_context(result.type_rank_context)
+          'type_rank_context' => serialize_type_rank_context(result.type_rank_context),
+          'applied_scope' => result.applied_scope
         }
       end
 
+      def rehydrate_scope(scope)
+        return nil unless scope
+
+        scope.transform_keys(&:to_sym).tap { |value| value[:outcome] = value[:outcome]&.to_sym }
+      end
+
       # type_rank_context is a Hash<String => Hash<Symbol, ...>> with
       # :source carrying a Symbol value. JSON-backed caches (Redis,
       # SolidCache) collapse both to strings on the round-trip, so we

data/lib/woods/cache/cache_store.rb

@@ -25,11 +25,10 @@ module Woods
     # @param parts [Array<String>] Key components (will be SHA256-hashed if long)
     # @return [String] Namespaced key
     def self.cache_key(domain, *parts)
-      raw = if parts.one?
-              parts.first.to_s
-            else
-              parts.map { |part| "#{part.to_s.bytesize}:#{part}" }.join
-            end
+      raw = parts.map do |part|
+        value = part.to_s
+        "#{value.bytesize}:#{value}"
+      end.join
       suffix = raw.length > 64 ? Digest::SHA256.hexdigest(raw) : raw
       "woods:cache:#{domain}:#{suffix}"
     end

data/lib/woods/change_set.rb

@@ -15,7 +15,8 @@ module Woods
   #
   # Paths are held absolute (matching how {DependencyGraph} registers file
   # paths) and exposed relative on demand (matching how {PathDispatcher}
-  # rules are written).
+  # rules are written). Normalization is lexical, so vanished files remain
+  # representable without resolving symlink targets or consulting the filesystem.
   #
   # @example
   #   cs = Woods::ChangeSet.new(paths: %w[app/models/user.rb app/models/gone.rb], root: Rails.root)
@@ -29,7 +30,7 @@ module Woods
     # @param paths [Array<String>] changed paths, absolute or root-relative
     # @param root [String, Pathname] application root (usually Rails.root)
     def initialize(paths:, root:)
-      @root = Pathname.new(root.to_s)
+      @root = Pathname.new(root.to_s).expand_path
       @absolute_paths = Array(paths).filter_map { |p| absolutize(p) }.uniq.freeze
     end
 
@@ -72,7 +73,7 @@ module Woods
     # @param path [String] absolute path
     # @return [String] root-relative path, or the input if outside {#root}
     def relativize(path)
-      prefix = "#{@root}/"
+      prefix = File.join(@root.to_s, '')
       path.start_with?(prefix) ? path.delete_prefix(prefix) : path
     end
 
@@ -82,7 +83,7 @@ module Woods
       str = path.to_s.strip
       return nil if str.empty?
 
-      Pathname.new(str).absolute? ? str : @root.join(str).to_s
+      @root.join(str).cleanpath.to_s
     end
   end
 end

data/lib/woods/console/credential_index.rb

@@ -68,6 +68,7 @@ module Woods
       MISSING_KEY_ERRORS = %w[
         ActiveSupport::EncryptedConfiguration::MissingKeyError
         ActiveSupport::EncryptedFile::MissingKeyError
+        ActiveSupport::EncryptedFile::MissingContentError
         ActiveSupport::MessageEncryptor::InvalidMessage
       ].freeze
 
@@ -90,13 +91,19 @@ module Woods
         # @return [CredentialIndex] populated index, or an empty index when
         #   the credentials store can't be opened.
         def build(rails_app:)
-          new(secrets: collect_secrets(rails_app))
+          refresh(rails_app: rails_app)
         rescue StandardError => e
           raise unless missing_key_error?(e)
 
           new(secrets: [])
         end
 
+        # Strict refresh: construct the replacement completely before a caller
+        # installs it. Unlike boot-time .build, errors must preserve the old index.
+        def refresh(rails_app:)
+          new(secrets: collect_secrets(rails_app))
+        end
+
         # Emit a structured log warning when any of the given credentials
         # files has a modification time newer than `process_start`. This
         # catches the common "rotated credentials but forgot to restart"
@@ -136,12 +143,23 @@ module Woods
         private
 
         def collect_secrets(rails_app)
-          config = rails_app.credentials.config
+          config = fresh_credentials(rails_app.credentials).config
           collected = []
           walk(config, collected)
           collected
         end
 
+        def fresh_credentials(credentials)
+          return credentials unless defined?(ActiveSupport::EncryptedConfiguration) &&
+                                    credentials.is_a?(ActiveSupport::EncryptedConfiguration)
+
+          require_relative 'encrypted_credential_snapshot'
+          EncryptedCredentialSnapshot.new(
+            config_path: credentials.content_path, key_path: credentials.key_path,
+            env_key: credentials.env_key, raise_if_missing_key: true
+          )
+        end
+
         def walk(node, collected)
           case node
           when Hash  then node.each_value { |v| walk(v, collected) }

data/lib/woods/console/credential_scanner.rb

@@ -155,17 +155,17 @@ module Woods
       #   for patterns that fired — callers should treat a missing key as zero.
       def scan(value)
         counts = {}
-        scanned = walk(value, counts)
+        scanned = walk(value, counts, @secret_index)
         [scanned, counts]
       end
 
       private
 
-      def walk(value, counts)
+      def walk(value, counts, index)
         case value
-        when String then scan_string(value, counts)
-        when Hash   then walk_hash(value, counts)
-        when Array  then value.map { |item| walk(item, counts) }
+        when String then scan_string(value, counts, index)
+        when Hash   then walk_hash(value, counts, index)
+        when Array  then value.map { |item| walk(item, counts, index) }
         else value
         end
       end
@@ -177,19 +177,19 @@ module Woods
       # credential-shaped string is emitted as a Symbol after redaction
       # (e.g. `:"[REDACTED]"`). String keys stay Strings. Non-String,
       # non-Symbol keys (Integer, etc.) pass through unchanged.
-      def walk_hash(hash, counts)
+      def walk_hash(hash, counts, index)
         hash.each_with_object({}) do |(key, val), out|
           scanned_key = case key
-                        when String then scan_string(key, counts)
-                        when Symbol then scan_string(key.to_s, counts).to_sym
+                        when String then scan_string(key, counts, index)
+                        when Symbol then scan_string(key.to_s, counts, index).to_sym
                         else             key
                         end
-          out[scanned_key] = walk(val, counts)
+          out[scanned_key] = walk(val, counts, index)
         end
       end
 
-      def scan_string(str, counts)
-        result = redact_indexed_secrets(str, counts)
+      def scan_string(str, counts, index)
+        result = redact_indexed_secrets(str, counts, index)
         result = scan_encoded_forms(result, counts)
         @active_patterns.inject(result) do |acc, (name, pattern)|
           acc.gsub(pattern) do
@@ -290,10 +290,10 @@ module Woods
         printable.to_f / str.length >= PRINTABLE_RATIO_THRESHOLD
       end
 
-      def redact_indexed_secrets(str, counts)
-        return str unless @secret_index&.match?(str)
+      def redact_indexed_secrets(str, counts, index)
+        return str unless index&.match?(str)
 
-        redacted = @secret_index.redact(str)
+        redacted = index.redact(str)
         counts[INDEX_HIT] = (counts[INDEX_HIT] || 0) + redacted.scan(CredentialIndex::REDACTED).size
         redacted
       end

data/lib/woods/console/credential_scanner_registry.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Woods
+  module Console
+    # Coordinates scanner construction and rotation without retaining servers
+    # after their transports release them. Requests keep their own index snapshot.
+    class CredentialScannerRegistry
+      def initialize
+        @scanners = ObjectSpace::WeakMap.new
+        @mutex = Mutex.new
+      end
+
+      def register
+        @mutex.synchronize do
+          scanner = yield
+          # Older Ruby WeakMap implementations validate the value's liveness
+          # when enumerating. Keep the scanner in both weak positions so an
+          # immortal sentinel cannot make an abandoned scanner look live.
+          @scanners[scanner] = scanner
+          scanner
+        end
+      end
+
+      def rebuild
+        @mutex.synchronize do
+          scanners = @scanners.values
+          return nil if scanners.empty?
+
+          index = yield
+          scanners.each { |scanner| scanner.replace_index!(index) }
+          index
+        end
+      end
+    end
+  end
+end

data/lib/woods/console/embedded_executor.rb

@@ -1491,7 +1491,7 @@ module Woods
         # `SqlNoiseStripper` is the same module SqlValidator uses. The
         # combined single-pass strip_noise resolves comments and literals
         # together so a comment marker inside a literal can't hide a keyword.
-        stripped = SqlNoiseStripper.strip_noise(template)
+        stripped = SqlNoiseStripper.strip_noise(template, dialect: sql_dialect || :postgres, **mysql_quote_modes)
         if SCOPE_TEMPLATE_FORBIDDEN.match?(stripped)
           raise ValidationError,
                 'scope template contains forbidden SQL keywords ' \

data/lib/woods/console/encrypted_credential_snapshot.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'active_support/encrypted_configuration'
+
+module Woods
+  module Console
+    # A private, uncached Rails configuration for one credential-index build.
+    # Unlike Rails' permissive configuration reader, a missing encrypted file
+    # must raise during an explicit refresh rather than erase the last index.
+    class EncryptedCredentialSnapshot < ActiveSupport::EncryptedConfiguration
+      def read
+        ActiveSupport::EncryptedFile.instance_method(:read).bind(self).call
+      end
+    end
+  end
+end

data/lib/woods/console/rack_middleware.rb

@@ -81,17 +81,12 @@ module Woods
       #   for compatibility. Passing it fails closed because console_eval is unavailable.
       # @param unsafe_eval_audit_log_path [String, Pathname, nil] Legacy option retained
       #   for compatibility. Passing it fails closed because console_eval is unavailable.
-      def initialize(app, path: '/mcp/console', embedded_read_tools: false, # rubocop:disable Metrics/ParameterLists
-                     unsafe_eval_confirmation: nil, unsafe_eval_audit_log_path: nil,
-                     stateless: true)
-        @app = app
-        @path = path
-        @embedded_read_tools = embedded_read_tools
-        @unsafe_eval_confirmation = unsafe_eval_confirmation
-        @unsafe_eval_audit_log_path = unsafe_eval_audit_log_path
-        @stateless = stateless
-        @mutex = Mutex.new
-        @transport = nil
+      # Rails 6.0 forwards middleware options as a positional hash on Ruby 3.
+      # Delegate to explicit keywords to preserve required/unknown option checks.
+      def initialize(app, options = {}, **keywords)
+        raise TypeError, 'middleware options must be a Hash' unless options.is_a?(Hash)
+
+        initialize_options(app, **options, **keywords)
       end
 
       # Rack interface — intercepts requests at the configured path.
@@ -99,7 +94,8 @@ module Woods
       # The enabled flag is read from Woods.configuration on every request,
       # never captured at construction: the railtie inserts this middleware
       # before config/initializers have run (#183). While
-      # `console_mcp_enabled` is false (the default), requests — even at the
+      # `console_mcp_enabled` is false (the default), or HTTP is explicitly
+      # disabled with `console_mcp_http_enabled = false`, requests — even at the
       # mounted path — pass through to the wrapped app unchanged, so a host
       # that never opted in is completely unaffected. Requests at
       # non-matching paths always pass through.
@@ -118,11 +114,24 @@ module Woods
 
       private
 
+      def initialize_options(app, path: '/mcp/console', embedded_read_tools: false, # rubocop:disable Metrics/ParameterLists
+                             unsafe_eval_confirmation: nil, unsafe_eval_audit_log_path: nil,
+                             stateless: true)
+        @app = app
+        @path = path
+        @embedded_read_tools = embedded_read_tools
+        @unsafe_eval_confirmation = unsafe_eval_confirmation
+        @unsafe_eval_audit_log_path = unsafe_eval_audit_log_path
+        @stateless = stateless
+        @mutex = Mutex.new
+        @transport = nil
+      end
+
       # Whether the console is enabled, read from the live configuration on
       # every request. Nil-safe: the railtie mounts this middleware in every
       # app (#183), including hosts that never called Woods.configure.
       def enabled?
-        Woods.configuration&.console_mcp_enabled
+        Woods.configuration&.console_mcp_enabled && Woods.configuration.console_mcp_http_enabled
       end
 
       # Thread-safe lazy initialization of the MCP server and transport.

data/lib/woods/console/server.rb

@@ -14,6 +14,7 @@ require_relative 'audit_logger'
 require_relative 'confirmation'
 require_relative 'console_response_renderer'
 require_relative 'credential_scanner'
+require_relative 'credential_scanner_registry'
 require_relative 'eval_guard'
 require_relative 'table_gate'
 require_relative 'redactor'
@@ -44,10 +45,14 @@ module Woods
     #   transport.open
     #
     module Server # rubocop:disable Metrics/ModuleLength
+      SCANNERS = CredentialScannerRegistry.new
+      private_constant :SCANNERS
+
       class << self # rubocop:disable Metrics/ClassLength
         # Rebuild the boot-time credential index from fresh Rails credentials
-        # and hot-swap it into the active scanner without restarting the process.
+        # and hot-swap it into every live scanner without restarting the process.
         #
+        # Refresh failures propagate without replacing any live index.
         # Host rotation jobs should call this immediately after `rails credentials:edit`
         # changes are deployed. The swap is atomic on MRI (GVL) — in-flight scans see
         # either the old or the new index, never a partial one.
@@ -62,14 +67,11 @@ module Woods
         #   the rebuild was skipped.
         def rebuild_credential_index(rails_app: nil)
           return nil unless credential_defense_enabled?
-          return nil unless @active_scanner
 
           target_app = rails_app || default_rails_app
           return nil unless target_app
 
-          new_index = CredentialIndex.build(rails_app: target_app)
-          @active_scanner.replace_index!(new_index)
-          new_index
+          SCANNERS.rebuild { CredentialIndex.refresh(rails_app: target_app) }
         end
 
         # True when Woods is configured and credential defense is on.
@@ -288,21 +290,21 @@ module Woods
                                        model_reflections: model_reflections)
                        end
 
-          secret_index = build_credential_index(config)
-          disabled_patterns = Array(config&.console_disabled_scanner_patterns)
-          scanner = if disabled_patterns.include?(:all)
-                      nil
-                    else
-                      CredentialScanner.new(
-                        disabled_patterns: disabled_patterns,
-                        secret_index: secret_index
-                      )
-                    end
-          @active_scanner = scanner
+          scanner = build_scanner(config)
 
           ResponseContext.build(safe_ctx: safe_ctx, table_gate: table_gate, credential_scanner: scanner)
         end
 
+        def build_scanner(config)
+          disabled_patterns = Array(config&.console_disabled_scanner_patterns)
+          return nil if disabled_patterns.include?(:all)
+
+          SCANNERS.register do
+            CredentialScanner.new(disabled_patterns: disabled_patterns,
+                                  secret_index: build_credential_index(config))
+          end
+        end
+
         # Build the boot-time credential index from Rails.application's encrypted
         # credentials. Returns nil when credential defense is disabled or when no
         # Rails application is reachable (specs, non-Rails hosts) — the scanner