woods 2.0.0.beta3 → 2.0.0.beta4

data/lib/woods/console/embedded_executor.rb

@@ -479,7 +479,7 @@ module Woods
       def handle_count(params)
         model = resolve_model(params['model'])
         scope = apply_scope(model, params['scope'], model_name: params['model'])
-        { 'count' => scope.count }
+        { 'count' => checked_relation(scope).count }
       end
 
       def handle_sample(params)
@@ -488,7 +488,7 @@ module Woods
         limit = params.fetch('limit', 5)
         scope = apply_scope(model, params['scope'], model_name: params['model'])
         scope = apply_columns(scope, params['columns'])
-        records = scope.order(random_function).limit(limit)
+        records = checked_relation(scope.order(random_function).limit(limit))
         { 'records' => serialize_records(records, params['columns']) }
       end
 
@@ -501,7 +501,8 @@ module Woods
         end
         validate_select_columns!(params)
         model = resolve_model(params['model'])
-        record = params['id'] ? model.find_by(id: params['id']) : model.find_by(params['by'])
+        scope = checked_relation(model)
+        record = params['id'] ? scope.find_by(id: params['id']) : scope.find_by(params['by'])
         { 'record' => record ? serialize_record(record, params['columns']) : nil }
       end
 
@@ -534,7 +535,7 @@ module Woods
         limit = params.fetch('limit', 100)
         scope = apply_scope(model, params['scope'], model_name: params['model'])
         scope = scope.distinct if params['distinct']
-        values = scope.limit(limit).pluck(*columns.map(&:to_sym))
+        values = checked_relation(scope.limit(limit)).pluck(*columns.map(&:to_sym))
         { 'columns' => Array(columns), 'values' => values }
       end
 
@@ -554,6 +555,7 @@ module Woods
 
         model = resolve_model(params['model'])
         scope = apply_scope(model, params['scope'], model_name: params['model'])
+        scope = checked_relation(scope)
 
         value = if function == 'count'
                   column ? scope.count(column.to_sym) : scope.count
@@ -566,6 +568,7 @@ module Woods
       def handle_association_count(params)
         model = resolve_model(params['model'])
         association_name = params['association']
+        requested_scope = params['scope']
         reflection = model.reflect_on_association(association_name.to_sym)
 
         raise ValidationError, "Unknown association '#{association_name}' on #{params['model']}" unless reflection
@@ -581,15 +584,33 @@ module Woods
         # association's own model before any database I/O runs (not just
         # before the association is read): `model.find` below is itself a
         # query, and a request with a bad scope should never reach it.
-        validate_scope_columns!(params['scope'], reflection.klass.name) if params['scope']
+        validate_scope_columns!(requested_scope, reflection.klass.name) if requested_scope
 
-        record = model.find(params['id'])
+        record = checked_relation(model).find(params['id'])
         scope = record.public_send(association_name)
-        scope = apply_scope(scope, params['scope'], model_name: reflection.klass.name) if params['scope']
+        scope = apply_scope(scope, requested_scope, model_name: reflection.klass.name) if requested_scope
         gate_association_sql!(scope)
         { 'count' => scope.count }
       end
 
+      # Materialize a model's default scope once, inspect the resolved SQL,
+      # and return that same relation for execution. Checking model.table_name
+      # alone misses default scopes that change FROM or introduce joins. Do
+      # not check model.all then issue a fresh query through the model: a
+      # dynamic default scope could differ between the check and execution.
+      # With no TableGate collaborator, retain the ungated executor contract.
+      #
+      # @param scope [Class, ActiveRecord::Relation] Pending model read
+      # @return [Class, ActiveRecord::Relation] Relation authorized for reading
+      # @raise [ValidationError] if its SQL references a blocked table
+      def checked_relation(scope)
+        return scope unless @table_gate
+
+        relation = scope.all
+        gate_sql!(relation.to_sql)
+        relation
+      end
+
       # Defense-in-depth: gate_association! (called by
       # {#handle_association_count} before this) only proves the
       # association's OWN target table isn't blocked. A through-association,
@@ -738,7 +759,7 @@ module Woods
 
         scope = apply_scope(model, params['scope'], model_name: params['model'])
         scope = apply_columns(scope, params['columns'])
-        records = scope.order(order_by => direction.to_sym).limit(limit)
+        records = checked_relation(scope.order(order_by => direction.to_sym).limit(limit))
         { 'records' => serialize_records(records, params['columns']) }
       end
 
@@ -798,13 +819,14 @@ module Woods
       # and PostgreSQL quote/comment grammars differ (`\'` escapes, `#`
       # comments); validating with the matching dialect accepts dialect-valid
       # literals and still rejects every known bypass form. Unknown adapters
-      # return nil and get the conservative both-dialect union.
+      # return nil and get the conservative union of supported dialects.
       #
       # @return [Symbol, nil]
       def sql_dialect
         adapter = active_connection.adapter_name.to_s.downcase
         return :mysql if adapter.include?('mysql')
         return :postgres if adapter.include?('postgre')
+        return :sqlite if adapter.include?('sqlite')
 
         nil
       end

data/lib/woods/console/sql_noise_stripper.rb

@@ -53,20 +53,21 @@ module Woods
       # single-quote scanner.
       #
       # @param sql [String] the SQL string to process
-      # @param dialect [Symbol] `:postgres` (default) or `:mysql`.
+      # @param dialect [Symbol] `:postgres` (default), `:mysql`, or `:sqlite`.
       #   - `:postgres` — single-quoted strings support `''` as an apostrophe
       #     escape. Backslash is treated literally and does not escape quotes.
       #     Dollar-quoted strings (`$$...$$`, `$tag$...$tag$`) are also stripped.
       #   - `:mysql` — single-quoted strings support both `\'` (backslash-escape)
       #     and `''` (doubled-quote) as apostrophe escapes. Dollar-quoted strings
       #     are not recognized by the combined MySQL security scanner.
+      #   - `:sqlite` — doubled apostrophes escape strings; backslashes and dollar signs are literal.
       # @return [String] a new string with all string literals replaced by `''`
       # @raise [ArgumentError] if an unsupported dialect is provided
       DOLLAR_QUOTED = /\$(\w*)\$.*?\$\1\$/m
       SINGLE_QUOTED_POSTGRES = /'(?:''|[^'])*'/m
       SINGLE_QUOTED_MYSQL    = /'(?:\\.|''|[^'])*'/m
 
-      SUPPORTED_DIALECTS = %i[postgres mysql].freeze
+      SUPPORTED_DIALECTS = %i[postgres mysql sqlite].freeze
       private_constant :SUPPORTED_DIALECTS
 
       def self.strip_literals(sql, dialect: :postgres)
@@ -76,7 +77,7 @@ module Woods
 
         # Strip dollar-quoted strings first so stray apostrophes inside them
         # do not interfere with the single-quote scanner.
-        out = sql.gsub(DOLLAR_QUOTED, "''")
+        out = dialect == :sqlite ? sql : sql.gsub(DOLLAR_QUOTED, "''")
 
         pattern = dialect == :mysql ? SINGLE_QUOTED_MYSQL : SINGLE_QUOTED_POSTGRES
         out.gsub(pattern, "''")
@@ -112,7 +113,7 @@ module Woods
       # still reads as following a boundary once comments are gone.
       #
       # @param sql [String] the SQL string to process
-      # @param dialect [Symbol] `:postgres` (default) or `:mysql` — controls
+      # @param dialect [Symbol] `:postgres` (default), `:mysql`, or `:sqlite` — controls
       #   single-quote escape rules (see {.strip_literals}) and whether `#`
       #   opens a line comment. MySQL quote flags reflect session sql_mode.
       # @return [String] a new string with comments removed and every string
@@ -134,7 +135,8 @@ module Woods
           if ch == "'"
             close = single_quote_end(
               sql, i,
-              backslash_escapes: (mysql && !no_backslash_escapes) || (!mysql && postgres_escape_string?(sql, i))
+              backslash_escapes: (mysql && !no_backslash_escapes) ||
+                (dialect == :postgres && postgres_escape_string?(sql, i))
             )
             if close
               out << "''"
@@ -158,7 +160,7 @@ module Woods
               out << ch
               i += 1
             end
-          elsif mysql && ch == '`'
+          elsif (mysql || dialect == :sqlite) && ch == '`'
             close = quoted_span_end(sql, i, quote: '`', backslash_escapes: false)
             if close
               # Backticks delimit identifiers. Preserve the token for table
@@ -170,7 +172,7 @@ module Woods
               out << ch
               i += 1
             end
-          elsif !mysql && ch == '$' && !preceded_by_word_char?(sql, i) && (tag = dollar_tag_at(sql, i))
+          elsif dialect == :postgres && ch == '$' && !preceded_by_word_char?(sql, i) && (tag = dollar_tag_at(sql, i))
             close = sql.index(tag, i + tag.length)
             if close
               out << "''"

data/lib/woods/console/sql_table_scanner.rb

@@ -167,6 +167,49 @@ module Woods
         results.uniq
       end
 
+      # Table-factor prefixes, retaining commas after balanced subqueries and
+      # JOIN predicates. Each nested FROM/JOIN is also scanned independently.
+      # @param sql [String] noise-stripped SQL
+      # @return [Array<String>]
+      def self.relation_factors(sql)
+        sql.to_enum(:scan, /\b(?:FROM|JOIN)\s+/i).flat_map do
+          suffix = sql[Regexp.last_match.end(0)..]
+          split_top_level_commas(relation_clause(suffix))
+        end
+      end
+
+      # Quoted tokens shield punctuation and clause words; a closing parenthesis
+      # at depth zero ends this query's clause, not a nested table expression.
+      def self.relation_clause(suffix)
+        depth = 0
+        tokens = /
+          "(?:[^"]|"")*"|`(?:[^`]|``)*`|''|[()]|
+          \b(?:WHERE|GROUP|HAVING|ORDER|LIMIT|OFFSET|UNION|INTERSECT|EXCEPT|WINDOW)\b
+        /ix
+        suffix.to_enum(:scan, tokens).each do
+          token = Regexp.last_match[0]
+          start = Regexp.last_match.begin(0)
+          finish = Regexp.last_match.end(0)
+          boundary = token == ')' || relation_keyword_boundary?(suffix[0...start], suffix[finish..], token)
+          return suffix[0...start] if depth.zero? && boundary
+
+          depth += 1 if token == '('
+          depth -= 1 if token == ')'
+        end
+        suffix
+      end
+      private_class_method :relation_clause
+
+      def self.relation_keyword_boundary?(prefix, rest, token)
+        return false unless token.match?(/\A[A-Za-z]/)
+        return false if prefix.strip.empty? || prefix.match?(/(?:,|\bAS)\s*\z/i) || rest.lstrip.start_with?(',')
+        return rest.match?(/\A\s+BY\b/i) if %w[GROUP ORDER].include?(token.upcase)
+        return rest.match?(/\A\s+\w+\s+AS\b/i) if token.casecmp?('WINDOW')
+
+        true
+      end
+      private_class_method :relation_keyword_boundary?
+
       # @api private
       # Every view of the stripped SQL the FROM/JOIN scans must consider for
       # MySQL executable comments (`/*! ... */`). {SqlNoiseStripper} leaves
@@ -203,12 +246,9 @@ module Woods
 
       # @api private
       def self.collect_from_identifiers(sql, results)
-        sql.scan(FROM_CLAUSE) do
-          clause = Regexp.last_match[:clause]
-          split_top_level_commas(clause).each do |chunk|
-            ident = lead_identifier(chunk)
-            results << ident if ident
-          end
+        relation_factors(sql).each do |chunk|
+          ident = lead_identifier(chunk)
+          results << ident if ident
         end
       end
       private_class_method :collect_from_identifiers
@@ -229,7 +269,7 @@ module Woods
         depth = 0
         buf = +''
         parts = []
-        clause.each_char do |ch|
+        clause.scan(/"(?:[^"]|"")*"|`(?:[^`]|``)*`|''|./m).each do |ch|
           case ch
           when '('
             depth += 1

data/lib/woods/console/sql_validator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'woods/console/sql_noise_stripper'
+require 'woods/console/sqlite_read_guard'
 
 # @see Woods
 module Woods
@@ -28,11 +29,11 @@ module Woods
     # named constants), not imperative logic.
     class SqlValidator # rubocop:disable Metrics/ClassLength
       # SQL dialects whose normalization the lock-clause check can run over.
-      KNOWN_DIALECTS = %i[postgres mysql].freeze
+      KNOWN_DIALECTS = %i[postgres mysql sqlite].freeze
 
       # The dialect the statement will execute under, when the caller knows
       # it. `nil` (the default) keeps the conservative union: every check
-      # runs against both dialect normalizations, which can reject a
+      # runs against all supported dialect normalizations, which can reject a
       # statement that is valid under one dialect's quote grammar (a MySQL
       # `\'` escape hides prose that the PostgreSQL view reads as SQL). When
       # the execution boundary knows the adapter, passing the matching
@@ -206,9 +207,9 @@ module Woods
       # function calls.
       FUNCTION_SCAN_EXCLUDED_KEYWORDS = %w[
         IN EXISTS NOT AND OR VALUES WHERE HAVING ON IS BETWEEN CASE WHEN
-        THEN ELSE END FROM JOIN USING WITH SELECT DISTINCT ALL ANY SOME
-        UNION INTERSECT EXCEPT ORDER GROUP BY ASC DESC LIMIT OFFSET AS INTO
-        OVER PARTITION FILTER WITHIN RETURNING EXPLAIN
+        THEN ELSE FROM JOIN USING SELECT DISTINCT ALL ANY SOME
+        UNION INTERSECT EXCEPT ORDER GROUP BY LIMIT OFFSET AS INTO
+        OVER FILTER RETURNING EXPLAIN
       ].freeze
 
       # EXPLAIN is a statement leader, so `EXPLAIN (FORMAT JSON) SELECT` is an
@@ -318,6 +319,7 @@ module Woods
 
         return validate_dialect_variants!(sql) if unknown_grammar?
 
+        SqliteReadGuard.validate!(sql) if dialect == :sqlite
         normalized = sql.strip
 
         # Reject multiple statements (semicolons not inside string literals)
@@ -582,10 +584,9 @@ module Woods
           match = Regexp.last_match
           quoted = !(match[1] || match[2]).nil?
           identifier = match[1] || match[2] || match[3]
-          # A bare keyword before `(` is grammar (IN/EXISTS/…), not a call; a
-          # quoted name before `(` is always a call, so keyword exclusion
-          # applies only to the bare form.
-          next if !quoted && FUNCTION_SCAN_EXCLUDED_KEYWORDS.include?(identifier.upcase)
+          # Some engines also allow keyword spellings as function names.
+          # Only exempt those names in their supported grammar positions.
+          next if !quoted && function_keyword_grammar?(identifier.upcase, stripped[0...match.begin(0)])
           next if ALLOWED_FUNCTIONS.include?(identifier.downcase)
 
           raise SqlValidationError,
@@ -594,6 +595,45 @@ module Woods
         end
       end
 
+      # Recognize keyword grammar without exempting identically named calls.
+      # The prefix is already stripped of comments and literal contents.
+      #
+      # @param keyword [String] Uppercase bare identifier before `(`.
+      # @param prefix [String] SQL preceding the identifier.
+      # @return [Boolean]
+      def function_keyword_grammar?(keyword, prefix)
+        return false unless FUNCTION_SCAN_EXCLUDED_KEYWORDS.include?(keyword)
+
+        case keyword
+        when 'EXPLAIN' then prefix.strip.empty?
+        when 'BY' then prefix.match?(/\b(?:ORDER|GROUP|PARTITION)\s*\z/i)
+        when 'OVER', 'FILTER' then prefix.match?(/\)\s*\z/)
+        when 'ANY', 'SOME' then comparison_quantifier?(prefix)
+        when 'OFFSET' then offset_grammar?(prefix)
+        else true
+        end
+      end
+
+      # SQLite has no quantified ANY/SOME comparison grammar; both spellings
+      # can instead invoke application-defined functions after an operator.
+      def comparison_quantifier?(prefix)
+        return true if dialect == :postgres # Reserved quantifiers, including LIKE ANY.
+
+        dialect != :sqlite && prefix.match?(/[=<>]\s*\z/)
+      end
+
+      # PostgreSQL reserves bare OFFSET (it cannot name a function), so its
+      # standalone OFFSET clause remains supported. Other dialects only accept
+      # parenthesized offsets after a completed LIMIT operand. Calls
+      # at an expression's start or after an operator are never offset syntax.
+      # Keep the supported operand boundary conservative: literals, bind
+      # numbers, parenthesized expressions, or PostgreSQL's LIMIT ALL.
+      def offset_grammar?(prefix)
+        return true if dialect == :postgres
+
+        prefix.match?(/(?:[0-9)'"`]|\bLIMIT\s+ALL)\s*\z/i)
+      end
+
       # Check if the SQL contains a forbidden keyword at a statement-leader
       # position after stripping comments and string literals. This catches
       # comment-hidden injections like "SELECT 1 --;\nDELETE FROM users",

data/lib/woods/console/sqlite_read_guard.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'woods/console/sql_noise_stripper'
+require 'woods/console/sql_table_scanner'
+
+module Woods
+  module Console
+    # Refuse SQLite-specific syntax outside the scanner's supported grammar.
+    # This is a conservative read boundary, not a general-purpose SQL parser.
+    module SqliteReadGuard
+      SIMPLE_IDENTIFIER = /\A[A-Za-z_][A-Za-z0-9_]*\z/
+      UNSUPPORTED_SYNTAX = /[^\x00-\x7F]|\$|\[|''\s*\(|\b(?:FROM|JOIN)(?=['"`(])/i
+      QUOTED_IDENTIFIER = /"(?:[^"]|"")*"|`(?:[^`]|``)*`/
+
+      # @param sql [String] SQL to execute on SQLite
+      # @raise [SqlValidationError] when an identifier or table factor cannot be checked
+      # @return [void]
+      def self.validate!(sql)
+        view = SqlNoiseStripper.strip_noise(sql, dialect: :sqlite)
+        refuse! if view.match?(UNSUPPORTED_SYNTAX)
+        view.scan(QUOTED_IDENTIFIER) { |quoted| refuse! unless quoted[1...-1].match?(SIMPLE_IDENTIFIER) }
+        SqlTableScanner.relation_factors(view).each do |factor|
+          refuse! unless supported_factor?(factor.strip)
+        end
+      end
+
+      # A SELECT/WITH subquery has its own independently scanned table factors.
+      # Parenthesized table groups and string-quoted names are refused rather
+      # than silently omitted from the blocked-table scan.
+      def self.supported_factor?(factor)
+        return true if factor.match?(/\A\(\s*(?:SELECT|WITH)\b/i)
+
+        match = SqlTableScanner::LEAD_IDENT.match(factor)
+        match && factor[match.end(0)..].match?(/\A(?:\s|,|\)|\z)/)
+      end
+      private_class_method :supported_factor?
+
+      def self.refuse!
+        raise SqlValidationError,
+              'Rejected: unsupported SQLite identifier or table-reference syntax. ' \
+              'Use simple bare or double-quoted identifiers and SELECT subqueries.'
+      end
+      private_class_method :refuse!
+    end
+  end
+end

data/lib/woods/coordination/pipeline_lock.rb

@@ -30,8 +30,9 @@ module Woods
       # The transaction-guard filename for a lock of +name+, exposed so
       # cleanup code that empties a lock directory (woods:clean) can skip the
       # guard during its sweep — deleting a flock'd guard out from under a
-      # contender's critical section would split the flock across two inodes —
-      # and remove it only after the lock is released.
+      # contender's critical section would split the flock across two inodes.
+      # The guard stays after cleanup and lock release: a new contender may
+      # already be holding it before its lock file exists.
       #
       # @param name [String]
       # @return [String]

data/lib/woods/embedding/indexer.rb

@@ -159,12 +159,11 @@ module Woods
         reconcile_empty_units(checkpoint)
         retire_legacy_identities
         report_checkpoint_misses
-        vanished = incremental && persistable? ? drop_vanished_units : 0
+        vanished = persistable? ? drop_vanished_units(incremental: incremental) : 0
         persist_snapshot if persistable? && snapshot_worth_writing?(stats, vanished, incremental: incremental)
         # Durable backends have no dump to rewrite, so staleness has to be
-        # removed from the store itself — on full runs too, since a full run
-        # against pgvector/Qdrant does not start from an empty store the way
-        # the in-memory path does (#211).
+        # removed from the store itself — on full runs too, since pgvector/
+        # Qdrant retain rows instead of replacing a published dump (#211).
         reconcile_durable_store if reconcilable?
         save_checkpoint(checkpoint)
 
@@ -275,20 +274,24 @@ module Woods
       # this costs no IO) and `@current_identifiers` is what this run saw.
       # Pruning with an empty fresh-id list removes every chunk of the unit.
       #
-      # Guarded by {#vanished_prune_permitted?} (B-079 / #191) — a refused
-      # prune returns 0, which reads as "nothing vanished" to
+      # Incremental runs use {#vanished_prune_permitted?} (B-079 / #191).
+      # A refused prune returns 0, which reads as "nothing vanished" to
       # {#snapshot_worth_writing?}, so a run that also embedded nothing writes
       # no dump and the retention window is not rotated over the good dumps.
       # The warn precedes the deletes: if the prune raises partway, the
       # operator still learns what it was doing.
       #
+      # Full rebuilds deliberately replace the complete corpus, including an
+      # empty corpus, even when callers reuse their in-memory stores.
+      #
+      # @param incremental [Boolean] whether to apply the incremental purge guard
       # @return [Integer] how many units were dropped
-      def drop_vanished_units
-        return 0 if @persisted_ids.nil? || @persisted_ids.empty?
+      def drop_vanished_units(incremental:)
+        return 0 if @persisted_ids.empty?
 
         vanished = @persisted_ids.keys.reject { |identifier| @current_identifiers.include?(identifier) }
         return 0 if vanished.empty?
-        return 0 unless vanished_prune_permitted?(vanished)
+        return 0 if incremental && !vanished_prune_permitted?(vanished)
 
         warn "[woods] dropping #{vanished.size} unit(s) from the vector index that the " \
              'extraction no longer holds; rewriting the dump.'
@@ -321,8 +324,8 @@ module Woods
       # Refusal never loses data: the stale vectors stay hydrated in the
       # store, so any dump this run does write (for freshly embedded work)
       # still carries them. Full runs never reach this guard —
-      # +drop_vanished_units+ runs only on the incremental path, and a full
-      # run's empty store is genuinely empty and must be dumped as such.
+      # a full run replaces the complete corpus and must publish even an empty
+      # result. Its vanished-unit reconciliation bypasses this guard.
       #
       # @param vanished [Array<String>] identifiers about to be pruned
       # @return [Boolean] true when the prune may proceed
@@ -357,9 +360,9 @@ module Woods
 
       # Delete vectors a durable store holds for units the index no longer has.
       #
-      # The dump-backed path gets staleness removal for free: the dump is
-      # rewritten from the live store each run, so a dropped unit simply stops
-      # being written. A durable backend has no such rewrite — rows in
+      # The dump-backed path removes vanished units from its hydrated or
+      # reused stores before publishing a replacement dump. A durable backend
+      # has no such rewrite — rows in
       # `woods_vectors` and points in Qdrant survive until something deletes
       # them, which nothing did. A unit deleted from the codebase therefore
       # stayed retrievable through `codebase_retrieve` indefinitely, *including
@@ -489,9 +492,16 @@ module Woods
           entries = []
           @vector_store.each_entry { |id, _vector, _metadata| entries << { id: id } }
           @persisted_ids = index_ids_by_identifier(entries)
+          retain_existing_metadata_identities
         end
       end
 
+      def retain_existing_metadata_identities
+        return unless @metadata_store.respond_to?(:each_entry)
+
+        @metadata_store.each_entry { |identifier, _unit| @persisted_ids[identifier] ||= [] }
+      end
+
       # Source-empty units retain metadata but intentionally have no vectors.
       # Keep those identities in the same deletion and typed-key accounting.
       def retain_metadata_identities

data/lib/woods/extractor.rb

@@ -211,7 +211,6 @@ module Woods
       configuration: :extract_configuration_file,
       view_template: :extract_view_template_file,
       migration: :extract_migration_file,
-      rake_task: :extract_rake_file,
       decorator: :extract_decorator_file,
       database_view: :extract_view_file,
       caching: :extract_caching_file,
@@ -293,7 +292,7 @@ module Woods
                  method: :extract_from_runtime_type, reconcile_removals: false }
     }.freeze
 
-    # Extractors with no per-file entry point: they scan the whole app (or
+    # Extractors requiring a complete source set: they scan the whole app (or
     # introspect the whole runtime) in one pass, so an incremental run
     # replaces their output wholesale rather than per unit. Before #164
     # these types were simply skipped by incremental runs while
@@ -302,6 +301,7 @@ module Woods
     #
     # @return [Hash{Symbol => Symbol}] extractor key => unit type
     WHOLE_APP_EXTRACTORS = {
+      rake_tasks: :rake_task,
       routes: :route,
       middleware: :middleware,
       engines: :engine,
@@ -600,6 +600,7 @@ module Woods
                       ))
       end
 
+      raise_on_handled_extraction_failure!
       finalize_incremental_unit_json(affected_types)
 
       # Regenerate type indexes for affected types
@@ -662,6 +663,7 @@ module Woods
         acc.merge(replace_type_wholesale(key, affected_types))
       end
 
+      raise_on_handled_extraction_failure!
       finalize_incremental_unit_json(affected_types)
       profile_phase('type index') { affected_types.each { |type_key| regenerate_type_index(type_key) } }
       finalize_incremental_run(touched, reason: "refresh:#{known.sort.join(',')}")
@@ -889,6 +891,7 @@ module Woods
     # Capture before eager loading or extraction; only an explicit fresh-launch
     # handoff can additionally establish the pre-Bundler/Rails boot boundary.
     def begin_source_inputs(operation)
+      @failed_consumers = Set.new
       @source_inputs = SourceInputs::Session.new(root: Rails.root, output_dir: @output_dir,
                                                  baseline_path: source_input_baseline_path,
                                                  operation: operation)
@@ -911,6 +914,28 @@ module Woods
       failed
     end
 
+    # A rescued consumer error is not a successful empty result. Reset the
+    # per-call flag because one extractor instance serves several paths, but
+    # retain the failed scope for the run so a later success cannot authorize
+    # publication. Watch then carries the complete batch forward for retry.
+    def checked_extraction(key, consumer)
+      (@failed_consumers ||= Set.new).add(key) if SourceInputs::ConsumerErrors.failed?(consumer)
+      SourceInputs::ConsumerErrors.reset(consumer)
+      result = yield
+      return result unless source_consumer_failed?(key, consumer)
+
+      (@failed_consumers ||= Set.new).add(key)
+      nil
+    end
+
+    def raise_on_handled_extraction_failure!
+      return if @failed_consumers.nil? || @failed_consumers.empty?
+
+      raise Woods::ExtractionError,
+            "Extraction failed for #{@failed_consumers.to_a.sort.join(', ')}; " \
+            'the previous generation remains active. Fix the logged source errors and retry the complete batch.'
+    end
+
     def write_source_inputs
       return unless @source_inputs
 
@@ -2760,10 +2785,11 @@ module Woods
     #
     # This is the fix for #164 gap 1 (a path the index has never seen routed
     # nowhere, so new files were silently ignored) and the per-path half of
-    # gap 3 (a file that defines several units — a `.rake` file with multiple
-    # tasks, an i18n YAML — could only ever resolve to one identifier).
-    # Reconciling the whole path at once means a task deleted from a
-    # multi-task file is removed rather than left behind.
+    # gap 3 (a file defining several units could only ever resolve to one
+    # identifier). Rake tasks need the wholesale path because definitions
+    # of one task can span several files.
+    # Reconciling the whole path removes definitions deleted from a surviving
+    # file rather than leaving them behind.
     #
     # Removal is scoped to the unit types the matching rules could have
     # produced, so a class-based unit sharing the path (the `User` model unit
@@ -2837,7 +2863,7 @@ module Woods
       end
       return [] unless extractor.respond_to?(rule.method_name)
 
-      result =
+      result = checked_extraction(rule.extractor_key, extractor) do
         if rule.extractor_key == :poros
           # PoroExtractor needs the AR name set to reject persisted models;
           # its default is an empty set, which would misfile every model
@@ -2846,6 +2872,8 @@ module Woods
         else
           extractor.public_send(rule.method_name, absolute_path)
         end
+      end
+      return nil if result.nil? && SourceInputs::ConsumerErrors.failed?(extractor)
 
       Array(result).compact
     rescue StandardError => e
@@ -3172,7 +3200,10 @@ module Woods
       return Set.new unless extractor.respond_to?(:extract_all)
 
       @wholesale_mutations = 0
-      units = Array(extractor.extract_all).compact.uniq(&:identifier)
+      result = checked_extraction(key, extractor) { extractor.extract_all }
+      return Set.new if SourceInputs::ConsumerErrors.failed?(extractor)
+
+      units = Array(result).compact.uniq(&:identifier)
       Rails.logger.info "[Woods] Re-ran #{key} wholesale: #{units.size} units"
 
       touched = register_and_write(key, units, affected_types)
@@ -3723,10 +3754,12 @@ module Woods
         return nil
       end
 
-      # File-based extractors can return several units from one file (a .rake
-      # file defining multiple tasks, etc.); class-based extractors return one.
-      units = Array(re_extracted_units(extractor, type, unit_id, file_path, extractor_key)).compact
-      source_consumer_failed?(extractor_key, extractor)
+      # File-based extractors can return several units from one file;
+      # class-based extractors return one.
+      result = checked_extraction(extractor_key, extractor) do
+        re_extracted_units(extractor, type, unit_id, file_path, extractor_key)
+      end
+      units = Array(result).compact
       return nil if units.empty?
 
       register_and_write(extractor_key, units, affected_types)