woods 2.0.0.beta1 → 2.0.0.beta3

data/lib/woods/storage/metadata_store.rb

@@ -84,16 +84,19 @@ module Woods
         # adapter — they were substitutable in name only until the semantics
         # were written down):
         #
-        # - **Substring match**, not word or prefix match.
+        # - **Literal substring match**, including embedded NUL, not word or prefix match.
         # - **Case-insensitive.** InMemory used a case-sensitive
         #   `String#include?` while SQLite used `LIKE`, so the same query
         #   returned different results depending on the configured backend.
         #   Case-insensitive is both the search-like expectation and what the
-        #   durable adapter already did. (SQLite's `LIKE` folds ASCII only, so
+        #   durable adapter already did. (SQLite's `lower` folds ASCII only, so
         #   non-ASCII case folding remains backend-specific — do not rely on
         #   it either way.)
         # - **`fields: nil` searches the whole record**, including keys, as
         #   serialized JSON. A query can therefore match a field *name*.
+        # - **Field-scoped values use JSON spellings.** Strings are unquoted,
+        #   objects/arrays use JSON text, Booleans use `true`/`false`, and
+        #   numbers remain numeric text. Null and absent fields never match.
         # - **LIKE metacharacters are literal.** `%` and `_` in a query match
         #   themselves rather than acting as wildcards.
         # - Field names are validated against {SEARCH_FIELD_NAME} by every
@@ -218,15 +221,14 @@ module Woods
         # @see Interface#search
         #
         # Matching is literal substring inclusion — `%` and `_` in the query
-        # have no special meaning here, and the SQLite adapter escapes them
-        # so the two adapters agree.
+        # have no special meaning here or in the SQLite adapter.
         #
         # @raise [ArgumentError] if a field name fails {SEARCH_FIELD_NAME}
         def search(query, fields: nil)
           fields = validate_search_fields!(fields)
           return [] if fields == []
 
-          # Case-insensitive, matching the SQLite adapter's `LIKE` (see the
+          # Case-insensitive, matching the SQLite adapter's `lower` (see the
           # contract note on {Interface#search}). This used to be a
           # case-sensitive `String#include?`, so the same query returned
           # different results depending on which backend a host had configured.
@@ -312,9 +314,9 @@ module Woods
           JSON.parse(JSON.generate(metadata))
         end
 
-        # The text SQLite's +json_extract(data, '$.field')+ would compare
-        # against for one field value: strings come back raw, structured
-        # values as their JSON text, scalars as their decimal form. A Ruby
+        # The searchable text for one field value: strings come back raw,
+        # structured values as JSON text, Booleans as true/false, and numbers
+        # as their decimal form. A Ruby
         # +Hash#to_s+ haystack used to leak `=>` and `:sym` syntax that no
         # JSON document contains (STO-8).
         #
@@ -425,23 +427,22 @@ module Woods
         # Field names are interpolated into a `json_extract` JSON-path
         # literal, so they are validated against {SEARCH_FIELD_NAME} first —
         # a crafted name could otherwise break out of the literal and alter
-        # the SQL shape. LIKE metacharacters (`%`, `_`, `\`) in the query are
-        # escaped (with an explicit ESCAPE clause) so they match literally,
-        # aligning with the InMemory adapter's substring semantics instead of
-        # silently broadening matches.
+        # the SQL shape. instr and lower perform literal, ASCII-case-insensitive
+        # substring matching without LIKE's truncation at embedded NUL bytes.
+        # Wildcard characters need no escaping.
         #
         # @raise [ArgumentError] if a field name fails the whitelist
         def search(query, fields: nil)
           fields = validate_search_fields!(fields)
           return [] if fields == []
 
-          pattern = "%#{escape_like(query)}%"
+          needle = query.to_s
           if fields
-            conditions = fields.map { "json_extract(data, '$.#{_1}') LIKE ? ESCAPE '\\'" }.join(' OR ')
-            params = Array.new(fields.size, pattern)
+            conditions = fields.map { "instr(lower(#{field_haystack_sql(_1)}), lower(?)) > 0" }.join(' OR ')
+            params = Array.new(fields.size, needle)
             rows = @db.execute("SELECT id, data FROM units WHERE #{conditions}", params)
           else
-            rows = @db.execute("SELECT id, data FROM units WHERE data LIKE ? ESCAPE '\\'", [pattern])
+            rows = @db.execute('SELECT id, data FROM units WHERE instr(lower(data), lower(?)) > 0', [needle])
           end
 
           rows.map { |row| parse_row(row) }
@@ -489,15 +490,14 @@ module Woods
           defined?(SQLite3::BusyException) && error.is_a?(SQLite3::BusyException)
         end
 
-        # Escape SQL LIKE metacharacters in a user query so they match
-        # literally under the `ESCAPE '\'` clause {#search} emits. Without
-        # this, `%` and `_` in a query act as wildcards and silently broaden
-        # matches (`"user_name"` would match `"userXname"`).
-        #
-        # @param query [String] Raw search query
-        # @return [String] Query safe for embedding in a LIKE pattern
-        def escape_like(query)
-          query.to_s.gsub(/[\\%_]/) { |ch| "\\#{ch}" }
+        # JSON1 extracts Boolean scalars as integers; use their JSON type to
+        # preserve true/false without conflating them with numeric 1/0.
+        # Field names have already passed validate_search_fields!.
+        def field_haystack_sql(field)
+          path = "$.#{field}"
+          "CASE json_type(data, '#{path}') " \
+            "WHEN 'true' THEN 'true' WHEN 'false' THEN 'false' " \
+            "ELSE json_extract(data, '#{path}') END"
         end
 
         # Parse a database row into a metadata hash with the id field injected.

data/lib/woods/storage/pgvector.rb

@@ -122,6 +122,9 @@ module Woods
           SQL
         end
 
+        # Native raw-ID eligibility is applied before ranking and the limit.
+        def supports_id_filter? = true
+
         # Search for similar vectors using cosine distance.
         #
         # The query vector is dimension-checked before SQL runs, mirroring the
@@ -136,19 +139,14 @@ module Woods
         # @raise [Woods::Error] if the query vector's length disagrees with the
         #   configured dimension
         # @see Interface#search
-        def search(query_vector, limit: 10, filters: {})
+        def search(query_vector, limit: 10, filters: {}, ids: nil)
           validate_vector!(query_vector)
           validate_dimensions!(query_vector) if @dimensions
           vector_literal = build_vector_literal(query_vector)
           where_clause = build_where(filters)
+          where_clause = append_id_filter(where_clause, ids) if ids
 
-          sql = <<~SQL
-            SELECT id, embedding <=> '#{vector_literal}' AS distance, metadata
-            FROM #{qualified_table}
-            #{where_clause}
-            ORDER BY distance ASC
-            LIMIT #{limit.to_i}
-          SQL
+          sql = search_sql(vector_literal, where_clause, limit, ids)
 
           rows = @connection.execute(sql)
           rows.map { |row| row_to_result(row) }
@@ -345,6 +343,29 @@ module Woods
           )
         end
 
+        def search_sql(vector_literal, where_clause, limit, ids)
+          source = ids ? 'eligible' : qualified_table
+          prefix = if ids
+                     'WITH eligible AS MATERIALIZED (SELECT id, embedding, metadata ' \
+                       "FROM #{qualified_table} #{where_clause})\n"
+                   else
+                     ''
+                   end
+          prefix + <<~SQL
+            SELECT id, embedding <=> '#{vector_literal}' AS distance, metadata
+            FROM #{source}
+            #{where_clause unless ids}
+            ORDER BY distance ASC#{', id ASC' if ids}
+            LIMIT #{limit.to_i}
+          SQL
+        end
+
+        # Raw IDs work with old vectors that have no identifier/package payload.
+        def append_id_filter(where_clause, ids)
+          condition = ids.empty? ? 'FALSE' : "id IN (#{ids.map { |id| @connection.quote(id.to_s) }.join(', ')})"
+          where_clause.empty? ? "WHERE #{condition}" : "#{where_clause} AND #{condition}"
+        end
+
         # Build a WHERE clause from metadata filters.
         #
         # @param filters [Hash] Metadata key-value pairs

data/lib/woods/storage/qdrant.rb

@@ -332,6 +332,9 @@ module Woods
           request(:put, "/collections/#{@collection}/points#{WAIT_FOR_WRITE}", body)
         end
 
+        # Native raw-ID eligibility is applied before ranking and the limit.
+        def supports_id_filter? = true
+
         # Search for similar vectors.
         #
         # The query vector is dimension-checked before the request, mirroring
@@ -348,14 +351,11 @@ module Woods
         # @raise [Woods::Error] if the query vector's length disagrees with the
         #   configured dimension
         # @see Interface#search
-        def search(query_vector, limit: 10, filters: {})
+        def search(query_vector, limit: 10, filters: {}, ids: nil)
+          return [] if ids == []
+
           validate_dimensions!(query_vector) if @dimensions
-          body = {
-            vector: query_vector,
-            limit: limit,
-            with_payload: true
-          }
-          body[:filter] = build_filter(filters) unless filters.empty?
+          body = search_body(query_vector, limit, filters, ids)
 
           response = request(:post, "/collections/#{@collection}/points/search", body)
           results = response['result'] || []
@@ -579,6 +579,16 @@ module Woods
                 "Vector dimension mismatch#{where}: got #{got}, expected #{@dimensions}"
         end
 
+        def search_body(query_vector, limit, filters, ids)
+          body = { vector: query_vector, limit: limit, with_payload: true }
+          body[:filter] = build_filter(filters) unless filters.empty? && ids.nil?
+          if ids
+            body[:filter][:must] << { key: IDENTIFIER_KEY, match: { any: ids } }
+            body[:params] = { exact: true }
+          end
+          body
+        end
+
         # Build a Qdrant filter from metadata key-value pairs.
         #
         # @param filters [Hash] Metadata filters

data/lib/woods/storage/vector_store.rb

@@ -90,12 +90,17 @@ module Woods
         # @param limit [Integer] Maximum number of results to return
         # @param filters [Hash] Optional metadata filters — values may be
         #   scalars or Arrays
+        # @param ids [Array<String>, nil] Raw vector IDs eligible before ranking;
+        #   optional capability advertised by #supports_id_filter?. Empty matches none.
         # @return [Array<SearchResult>] Results sorted by descending similarity
         # @raise [NotImplementedError] if not implemented by adapter
-        def search(query_vector, limit: 10, filters: {})
+        def search(query_vector, limit: 10, filters: {}, ids: nil)
           raise NotImplementedError
         end
 
+        # Whether native raw-ID eligibility is supported before the result limit.
+        def supports_id_filter? = false
+
         # Delete a vector by ID.
         #
         # @param id [String] The identifier to delete
@@ -220,8 +225,10 @@ module Woods
           end
         end
 
+        def supports_id_filter? = true
+
         # @see Interface#search
-        def search(query_vector, limit: 10, filters: {})
+        def search(query_vector, limit: 10, filters: {}, ids: nil)
           return [] if @dim.nil?
 
           unless query_vector.length == @dim
@@ -229,8 +236,8 @@ module Woods
                   "Vector dimension mismatch (#{query_vector.length} vs #{@dim})"
           end
 
-          scored = gather_candidates(query_vector, filters)
-          scored.sort_by! { |r| -r.score }
+          scored = gather_candidates(query_vector, filters, ids)
+          scored.sort_by! { |r| ids ? [-r.score, r.id] : [-r.score] }
           scored.first(limit)
         end
 
@@ -300,15 +307,20 @@ module Woods
           @metadata[idx] = metadata
         end
 
+        def excluded_index?(idx, allowed_ids)
+          @tombstones.include?(idx) || (allowed_ids && !allowed_ids.include?(@ids[idx]))
+        end
+
         # Walk every non-tombstoned index, apply filters, score survivors.
         # Filter check runs BEFORE the cosine kernel — avoids computing
         # 12k dot products only to discard most of them.
-        def gather_candidates(query_vector, filters)
+        def gather_candidates(query_vector, filters, ids)
           scored = []
+          allowed_ids = ids&.to_set
           len = @ids.size
           idx = 0
           while idx < len
-            if @tombstones.include?(idx)
+            if excluded_index?(idx, allowed_ids)
               idx += 1
               next
             end

data/lib/woods/tasks.rb

@@ -27,6 +27,7 @@ module Woods
     # @return [Embedding::Indexer]
     def build_embed_indexer
       config = Woods.configuration
+      output_dir = ENV.fetch('WOODS_OUTPUT', config.output_dir)
       builder = Builder.new(config)
       provider = builder.build_embedding_provider
 
@@ -56,11 +57,11 @@ module Woods
         provider: resilient_provider,
         text_preparer: builder.build_text_preparer(provider),
         vector_store: vector_store,
-        metadata_store: config.metadata_store ? builder.build_metadata_store : nil,
+        metadata_store: config.metadata_store ? builder.build_metadata_store(output_dir: output_dir) : nil,
         resolved_config: build_resolved_config(config, provider: provider),
         chunker: builder.build_chunker(provider),
         dump_retention_count: config.dump_retention_count,
-        output_dir: ENV.fetch('WOODS_OUTPUT', config.output_dir)
+        output_dir: output_dir
       )
     end
 

data/lib/woods/temporal/json_snapshot_store.rb

@@ -22,7 +22,8 @@ module Woods
     #
     # Implements the same public interface as SnapshotStore so the MCP server
     # tools work identically.
-    # Malformed retained snapshots are warned about and treated as absent:
+    # Malformed, non-object, or unreadable retained snapshots (including files
+    # removed during retention) are warned about and treated as absent:
     # +find+ returns nil, +diff+ returns an empty result, and history/list scans
     # omit the corrupt file.
     #
@@ -122,9 +123,9 @@ module Woods
         value.positive? ? value : PayloadStore::DEFAULT_RETENTION
       end
 
-      # Delete snapshots beyond the retention count, oldest by extracted_at
-      # first. +protect+ names the snapshot just captured; it is the newest
-      # anyway, and a tie on extracted_at must not delete it.
+      # Delete snapshots beyond the retention count, corrupt/unreadable files
+      # first, then oldest by extracted_at. +protect+ names the snapshot just
+      # captured; even an older timestamp must not cause its deletion.
       #
       # Failures are non-fatal: retention is housekeeping, and a failed
       # prune leaves the store growing as it did before rather than
@@ -133,7 +134,7 @@ module Woods
       # @param protect [String] git SHA of the just-captured snapshot
       # @return [void]
       def prune_snapshots(protect:)
-        summaries = load_all_summaries
+        summaries = retention_summaries
         overflow = summaries.size - @retention
         return unless overflow.positive?
 
@@ -142,7 +143,21 @@ module Woods
         warn "[Woods] Snapshot retention failed: #{e.message}"
       end
 
-      # Oldest `overflow` snapshots by extracted_at, never the protected one.
+      # Include unreadable snapshots in the bound. Only files named like a
+      # snapshot are eligible; the filename owns identity, not JSON content.
+      def retention_summaries
+        Dir.glob(File.join(@dir, '*.json')).filter_map do |path|
+          sha = File.basename(path, '.json')
+          next unless sha.match?(/\A[0-9a-f]+\z/i) && File.file?(path)
+
+          data = read_snapshot(path) || {}
+          timestamp = data['extracted_at']
+          valid = data['git_sha'] == sha && timestamp.is_a?(String)
+          { git_sha: sha, extracted_at: valid ? timestamp : '', corrupt: !valid }
+        end
+      end
+
+      # Corrupt files, then oldest `overflow` snapshots, never the protected one.
       # The protected SHA is rejected before sorting and slicing: it is
       # captured last, so its extracted_at can tie or precede older entries,
       # and letting it occupy the victim slice would leave the store one file
@@ -154,7 +169,7 @@ module Woods
       # @return [Array<String>]
       def retention_victims(summaries, overflow, protect)
         summaries.reject { |summary| summary[:git_sha] == protect }
-                 .sort_by { |summary| summary[:extracted_at] || '' }
+                 .sort_by { |summary| [summary[:corrupt] ? 0 : 1, summary[:extracted_at], summary[:git_sha]] }
                  .first(overflow)
                  .map { |summary| summary[:git_sha] }
       end
@@ -264,10 +279,16 @@ module Woods
       end
 
       def read_snapshot(path)
-        JSON.parse(AtomicFile.read(path))
+        data = JSON.parse(AtomicFile.read(path))
+        raise JSON::ParserError, 'expected a JSON object' unless data.is_a?(Hash)
+
+        data
       rescue JSON::ParserError => e
         warn "[Woods] Skipping corrupt snapshot #{File.basename(path)}: #{e.message}"
         nil
+      rescue SystemCallError => e
+        warn "[Woods] Skipping unreadable snapshot #{File.basename(path)}: #{e.message}"
+        nil
       end
 
       # @param exclude_sha [String, nil] SHA to leave out of the result

data/lib/woods/unblocked/exporter.rb

@@ -8,6 +8,7 @@ require_relative 'client'
 require_relative 'rate_limiter'
 require_relative 'document_builder'
 require_relative 'sync_manifest'
+require_relative '../export/typed_reader'
 
 module Woods
   module Unblocked
@@ -75,6 +76,7 @@ module Woods
 
         @client = client || Client.new(api_token: api_token, rate_limiter: limiter)
         @reader = reader || build_reader(index_dir)
+        @typed_reader = Export::TypedReader.new(@reader)
         # Cite the ref the index was actually extracted from. `main` was
         # hardcoded, so citations on a `master`-default repo pointed at a
         # branch that need not exist.
@@ -96,10 +98,11 @@ module Woods
       #
       # @return [Hash] { synced:, skipped:, deleted:, errors: }
       def sync_all
-        with_pinned_index do
+        prepared = false
+        with_prepared_index do
+          prepared = true
           @current_uris = Set.new
           @budget_exhausted = false
-          build_uri_index
           reconcile_from_remote if @manifest.empty?
 
           synced = 0
@@ -108,6 +111,7 @@ module Woods
 
           FULL_SYNC_TYPES.each do |type|
             break if @budget_exhausted
+            next if type.start_with?('graphql_') # the family already includes these actual types
 
             result = sync_type(type)
             synced += result[:synced]
@@ -124,11 +128,11 @@ module Woods
             errors.concat(result[:errors])
           end
 
-          deleted = @budget_exhausted ? 0 : purge_stale(errors)
+          deleted = @budget_exhausted || @ambiguous_uris.any? ? 0 : purge_stale(errors)
           { synced: synced, skipped: skipped, deleted: deleted, errors: cap_errors(errors) }
         end
       ensure
-        save_manifest
+        save_manifest if prepared
       end
 
       # Sync all units of a given type.
@@ -136,10 +140,12 @@ module Woods
       # @param type [String] Unit type (e.g. "model", "controller")
       # @return [Hash] { synced:, skipped:, errors: }
       def sync_type(type)
-        units = @reader.list_units(type: type)
-        log "  #{type}: #{units.size} units"
+        with_prepared_index do
+          units = units_for(type)
+          log "  #{type}: #{units.size} units"
 
-        sync_units(units)
+          sync_unit_data(units.map { |unit| [unit, unit] })
+        end
       end
 
       # Sync the top N most-connected units of a type (by dependent count).
@@ -148,35 +154,42 @@ module Woods
       # @param max_count [Integer] Maximum units to sync
       # @return [Hash] { synced:, skipped:, errors: }
       def sync_type_partial(type, max_count)
-        units = @reader.list_units(type: type)
-        return empty_stats if units.empty?
-
-        # Load full data to sort by dependent count
-        units_with_data = units.filter_map do |entry|
-          data = @reader.find_unit(entry['identifier'])
-          next unless data
-
-          dep_count = (data['dependents'] || []).size
-          { entry: entry, data: data, dep_count: dep_count }
+        with_prepared_index do
+          units = units_for(type)
+          units.each { |unit| track_uri(unit) }
+          top = units.sort_by { |unit| -(unit['dependents'] || []).size }.first(max_count)
+          log "  #{type}: #{top.size}/#{units.size} units (top by dependents)"
+          result = sync_unit_data(top.map { |unit| [unit, unit] })
+          result[:skipped] += units.size - top.size
+          result
         end
+      end
 
-        # Every unit of this type still exists — track its URI so partial units
-        # that fall *out* of the top-N are never mistaken for deletions.
-        units_with_data.each { |u| track_uri(u[:data]) }
-
-        top_units = units_with_data.sort_by { |u| -u[:dep_count] }.first(max_count)
-        # Count against what was actually synced — units.size includes entries
-        # whose unit data was missing (dropped by the filter_map above).
-        skipped_count = units.size - top_units.size
+      private
 
-        log "  #{type}: #{top_units.size}/#{units.size} units (top by dependents)"
+      # Complete preflight precedes all remote writes and destructive pruning.
+      # Nested sync methods share this snapshot; standalone methods pin as well.
+      def with_prepared_index
+        return yield if @prepared_index
 
-        result = sync_unit_data(top_units.map { |u| [u[:entry], u[:data]] })
-        result[:skipped] += skipped_count
-        result
+        with_pinned_index do
+          @published_units = @typed_reader.all
+          build_uri_index
+          @prepared_index = true
+          begin
+            yield
+          ensure
+            @prepared_index = false
+            @published_units = nil
+          end
+        end
       end
 
-      private
+      def units_for(type)
+        # The historical graphql family includes all four actual subtypes.
+        types = type == 'graphql' ? MCP::IndexReader::UNIT_TYPES_BY_DIR.fetch('graphql') : [type]
+        @published_units.select { |unit| types.include?(unit['type']) }
+      end
 
       # Run a multi-read export body against one index generation.
       #
@@ -197,36 +210,6 @@ module Woods
         @reader.with_pinned_generation(&block)
       end
 
-      def sync_units(units)
-        synced = 0
-        skipped = 0
-        errors = []
-
-        units.each do |entry|
-          unit_data = @reader.find_unit(entry['identifier'])
-          unless unit_data
-            skipped += 1
-            next
-          end
-
-          track_uri(unit_data)
-          if push_document(unit_data) == :skipped
-            skipped += 1
-          else
-            synced += 1
-          end
-        rescue Woods::Error => e
-          errors << "#{entry['identifier']}: #{e.message}"
-          break if note_budget_exhaustion(e)
-        rescue StandardError => e
-          # Include the class — "undefined method for nil" without it is
-          # unactionable in CI logs.
-          errors << "#{entry['identifier']}: #{e.class}: #{e.message}"
-        end
-
-        { synced: synced, skipped: skipped, errors: errors }
-      end
-
       def sync_unit_data(entries_with_data)
         synced = 0
         skipped = 0
@@ -256,6 +239,10 @@ module Woods
       #
       # @return [Symbol] :synced or :skipped
       def push_document(unit_data)
+        if @ambiguous_uris.include?(@builder.uri_for(unit_data))
+          raise ExtractionError,
+                "ambiguous export URI for #{unit_data['type']}:#{unit_data['identifier']} — push skipped"
+        end
         # No file_path → the URI falls back to the bare repo URL, which every
         # such unit would share: they'd overwrite each other remotely and
         # ping-pong the manifest hash forever. Skip them.
@@ -411,24 +398,26 @@ module Woods
         "#{base}?unit=#{URI.encode_www_form_component(unit_data['identifier'])}"
       end
 
-      # One cheap pass over the type indexes (entries already carry file_path,
-      # and read_index is cached) to find files that define more than one synced
-      # unit. For each such base URI, the lexically-smallest identifier — the
+      # Inspect the complete validated snapshot, including excluded types, for
+      # same-name cross-type collisions. For files with distinct synced names,
+      # the lexically-smallest identifier — the
       # outer/top-level class — keeps the bare URI; siblings are suffixed. Solo
       # files (the overwhelming majority) are absent from the map and unchanged,
       # so this introduces no churn for them.
       def build_uri_index
         groups = Hash.new { |h, k| h[k] = [] }
-        synced_types.each do |type|
-          @reader.list_units(type: type).each do |entry|
-            next unless entry['file_path']
+        @published_units.each do |unit|
+          next unless unit['file_path']
 
-            groups[@builder.uri_for(entry)] << entry['identifier']
-          end
+          groups[@builder.uri_for(unit)] << unit
         end
 
-        @uri_primary = groups.each_with_object({}) do |(uri, identifiers), primary|
-          unique = identifiers.uniq
+        @ambiguous_uris = groups.each_with_object(Set.new) do |(uri, units), ambiguous|
+          identities = units.map { |unit| [unit['identifier'], unit['type']] }.uniq
+          ambiguous << uri if identities.group_by(&:first).any? { |_, variants| variants.size > 1 }
+        end
+        @uri_primary = groups.each_with_object({}) do |(uri, units), primary|
+          unique = units.select { |unit| synced_types.include?(unit['type']) }.map { |unit| unit['identifier'] }.uniq
           primary[uri] = unique.min if unique.size > 1
         end
       end

data/lib/woods/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Woods
-  VERSION = '2.0.0.beta1'
+  VERSION = '2.0.0.beta3'
 end

data/lib/woods/watch/boot_snapshot.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative '../reload_policy'
+require_relative 'tree_scan'
+require_relative 'watcher'
+
+module Woods
+  module Watch
+    # Files observed before the watch task invokes Rails' environment task.
+    # This bounds environment initialization, not earlier Bundler/application
+    # loading. Hosts embedding the daemon may provide the same explicit boundary.
+    class BootSnapshot
+      def initialize(root:, policy: ReloadPolicy.new)
+        @root = File.expand_path(root.to_s)
+        @policy = policy
+        @files = scan
+      end
+
+      # True for unchanged files, including a carried path absent before and
+      # after boot. A deleted initializer must not demand another restart.
+      def covers?(path)
+        absolute = File.expand_path(path, @root)
+        @files[absolute] == fingerprint(absolute)
+      end
+
+      # Includes additions and deletions, even if another writer has advanced
+      # the index watermark while Rails was booting.
+      def changed_paths
+        current = scan
+        (@files.keys | current.keys).reject { |path| @files[path] == current[path] }
+      end
+
+      private
+
+      def scan
+        TreeScan.files(root: @root, ignored: Watcher::DEFAULT_IGNORED_DIRECTORIES).each_with_object({}) do |path, files|
+          next unless %i[restart reload].include?(@policy.classify(path.delete_prefix("#{@root}/")))
+
+          stamp = fingerprint(path)
+          files[path] = stamp if stamp
+        end
+      end
+
+      def fingerprint(path)
+        stat = File.stat(path)
+        [stat.ino, stat.size, stat.mtime, stat.ctime]
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        nil
+      end
+    end
+  end
+end