woods 1.6.1 → 2.0.0.beta2

data/lib/tasks/woods_checks.rake

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+# lib/tasks/woods_checks.rake
+#
+# Deterministic checks over a published index (#280). None of these boot
+# Rails: they read retained payload generations through Woods::PublishedIndex.
+#
+# Usage:
+#   bundle exec rake woods:check:moved_messages          # previous vs published generation
+#   bundle exec rake "woods:check:moved_messages[41,42]" # explicit generations
+#   WOODS_CHECK_STRICT=1 ...                             # exit 1 on findings (still heuristic; see below)
+
+require 'json'
+
+namespace :woods do
+  namespace :check do
+    desc 'Candidate moves into a unit without mapped tests, between two retained generations ' \
+         '(heuristic: name+kind match, not a proven coverage loss; see docs/PUBLISHED_INDEX.md)'
+    task :moved_messages, %i[from to] do |_task, args|
+      Woods::CheckTasks.run_moved_messages(from: args[:from], to: args[:to])
+    end
+  end
+end
+
+module Woods
+  # Bodies of the `woods:check:*` tasks. A module, not bare defs, so nothing
+  # lands on Object in the host application.
+  module CheckTasks
+    module_function
+
+    # @param from [String, Integer, nil] older generation; defaults to the one before `to`
+    # @param to [String, Integer, nil] newer generation; defaults to the published one
+    # @return [void]
+    def run_moved_messages(from: nil, to: nil)
+      require 'woods/published_index'
+      require 'woods/checks/moved_messages'
+      require 'woods/checks/generation_resolution'
+
+      index_dir = check_index_dir
+      available = Woods::PublishedIndex.available_generations(index_dir)
+      resolved = Woods::Checks::GenerationResolution.call(available, from: from, to: to)
+      abort_for_insufficient_generations(index_dir, available) unless resolved
+
+      from_number, to_number = resolved
+      puts "Comparing generation #{from_number} to #{to_number} under #{index_dir}"
+
+      findings = compare_generations(index_dir, from_number, to_number)
+
+      print_moved_messages(findings)
+      exit 1 if findings.any? && ENV['WOODS_CHECK_STRICT'] == '1'
+    rescue Woods::PublishedIndex::CorruptPointerError => e
+      # Let it propagate (a corrupt install is not "0 findings"), but name the
+      # task first: a bare CorruptPointerError backtrace from deep inside
+      # PublishedIndex gives no hint this came from a rake task at all.
+      warn "woods:check:moved_messages: #{e.message}"
+      raise
+    end
+
+    # WOODS_OUTPUT, or tmp/woods beside the loaded Rakefile (the same
+    # resolution woods:watch_status uses; no Rails boot).
+    #
+    # @return [String]
+    def check_index_dir
+      ENV.fetch('WOODS_OUTPUT') do
+        root = respond_to?(:woods_task_root, true) ? woods_task_root : Rake.application.original_dir
+        File.join(root, 'tmp/woods')
+      end
+    end
+
+    # @param index_dir [String]
+    # @param from_number [Integer]
+    # @param to_number [Integer]
+    # @return [Array<Woods::Checks::MovedMessages::Finding>]
+    def compare_generations(index_dir, from_number, to_number)
+      Woods::PublishedIndex.open(index_dir, generation: from_number) do |before|
+        Woods::PublishedIndex.open(index_dir, generation: to_number) do |after|
+          Woods::Checks::MovedMessages.new(before: before, after: after).run
+        end
+      end
+    end
+
+    # @param index_dir [String]
+    # @param available [Array<Integer>]
+    # @return [void]
+    def abort_for_insufficient_generations(index_dir, available)
+      warn "ERROR: need two retained generations under #{index_dir}; found #{available.inspect}."
+      warn 'Run two extractions, or raise WOODS_PAYLOAD_RETENTION, or pass [from,to] explicitly.'
+      exit 1
+    end
+
+    # @param findings [Array<Woods::Checks::MovedMessages::Finding>]
+    # @return [void]
+    def print_moved_messages(findings)
+      if findings.empty?
+        puts 'No candidate moves into a unit without mapped tests.'
+        return
+      end
+
+      puts "#{findings.size} candidate move(s) into a unit without mapped tests:"
+      findings.each do |finding|
+        puts "  #{finding.method} (#{finding.kind}): #{finding.from_unit} -> #{finding.to_unit} " \
+             "(covered before: #{finding.covered_before}, covered after: #{finding.covered_after})"
+      end
+      puts JSON.pretty_generate(findings.map(&:to_h)) if ENV['WOODS_CHECK_JSON'] == '1'
+    end
+  end
+end

data/lib/tasks/woods_evaluation.rake

@@ -5,111 +5,195 @@
 # Rake tasks for evaluating retrieval quality.
 #
 # Usage:
-#   bundle exec rake woods:evaluate                          # Run evaluation
-#   bundle exec rake woods:evaluate:baseline[grep]           # Run baseline comparison
+#   bundle exec rake woods:evaluate                # Run evaluation
+#   bundle exec rake "woods:evaluate:baseline[grep]"  # Run baseline comparison
+#
+# Loaded by the railtie alongside woods.rake. It previously was not loaded at
+# all, so neither task existed on any host — and the code below called
+# `Woods.vector_store` / `Woods.metadata_store` / `Woods.graph_store` /
+# `Woods.embedding_provider`, none of which have ever existed. Both halves are
+# fixed together (#212): stores now come from the MCP bootstrapper, the same
+# path that hydrates persisted vector/metadata/graph artifacts for retrieval.
+#
+# Offline runs need no API key — set `embedding_provider = :fake` (#178).
+
+require 'woods'
 
 namespace :woods do
   desc 'Run evaluation queries against the retrieval pipeline'
   task evaluate: :environment do
-    require 'woods/retriever'
-    require 'woods/evaluation/query_set'
-    require 'woods/evaluation/evaluator'
-    require 'woods/evaluation/report_generator'
-
-    run_evaluation
+    Woods::EvaluationTasks.run_evaluation
   end
 
   namespace :evaluate do
-    desc 'Run baseline comparison'
+    desc 'Run baseline comparison (strategy: grep, random, or file_level)'
     task :baseline, [:strategy] => :environment do |_t, args|
-      require 'woods/evaluation/query_set'
-      require 'woods/evaluation/baseline_runner'
-      require 'woods/evaluation/metrics'
+      Woods::EvaluationTasks.run_baseline(strategy: args[:strategy])
+    end
 
-      run_baseline(args)
+    desc 'Agent-level ablation: run a task set with the index on and off, ' \
+         'each trial in a disposable worktree (no Rails boot)'
+    task :ablation, [:task_set] do |_t, args|
+      Woods::EvaluationTasks.run_ablation(task_set_path: args[:task_set])
     end
   end
 end
 
-def run_evaluation
-  query_set_path = ENV.fetch('EVAL_QUERY_SET', 'config/eval_queries.json')
-  output_path = ENV.fetch('EVAL_OUTPUT', 'tmp/eval_report.json')
-  budget = ENV.fetch('EVAL_BUDGET', '8000').to_i
+module Woods
+  # Bodies of the `woods:evaluate` rake tasks.
+  #
+  # A module rather than top-level `def`s: a rake file's bare methods land on
+  # Object and become callable on every object in the host application.
+  module EvaluationTasks
+    DEFAULT_QUERY_SET = 'config/eval_queries.json'
+    DEFAULT_OUTPUT = 'tmp/eval_report.json'
+    DEFAULT_BUDGET = 8000
+    DEFAULT_BASELINE_LIMIT = 10
+
+    module_function
+
+    # Evaluate the real retrieval pipeline against a ground-truth query set.
+    #
+    # @return [void]
+    def run_evaluation
+      require 'woods/mcp/bootstrapper'
+      require 'woods/evaluation/query_set'
+      require 'woods/evaluation/evaluator'
+      require 'woods/evaluation/report_generator'
+      require 'woods/evaluation/baseline'
 
-  puts "Loading query set from: #{query_set_path}"
-  query_set = Woods::Evaluation::QuerySet.load(query_set_path)
-  puts "Loaded #{query_set.size} queries — building retriever..."
+      query_set_path, output_path, budget = eval_run_config
+      thresholds = build_thresholds
 
-  evaluator = Woods::Evaluation::Evaluator.new(
-    retriever: build_eval_retriever, query_set: query_set, budget: budget
-  )
-  report = evaluator.evaluate
+      puts "Loading query set from: #{query_set_path}"
+      query_set = Evaluation::QuerySet.load(query_set_path)
+      puts "Loaded #{query_set.size} queries — building retriever..."
 
-  Woods::Evaluation::ReportGenerator.new
-                                    .save(report, output_path, metadata: { 'query_set' => query_set_path })
+      report = Evaluation::Evaluator.new(
+        retriever: build_eval_retriever, query_set: query_set, budget: budget, thresholds: thresholds
+      ).evaluate
 
-  print_eval_report(report, output_path)
-end
+      Evaluation::ReportGenerator.new
+                                 .save(report, output_path, metadata: { 'query_set' => query_set_path })
 
-def run_baseline(args)
-  strategy = (args[:strategy] || ENV.fetch('EVAL_BASELINE_STRATEGY', 'grep')).to_sym
-  query_set_path = ENV.fetch('EVAL_QUERY_SET', 'config/eval_queries.json')
-  limit = ENV.fetch('EVAL_BASELINE_LIMIT', '10').to_i
+      print_eval_report(report, output_path)
+      exit 1 if report.threshold_report && !report.threshold_report.passed
+    end
 
-  puts "Loading query set from: #{query_set_path}"
-  query_set = Woods::Evaluation::QuerySet.load(query_set_path)
-  puts "Running #{strategy} baseline (limit: #{limit})..."
+    # @return [Array(String, String, Integer)] query_set_path, output_path, budget
+    def eval_run_config
+      [ENV.fetch('EVAL_QUERY_SET', DEFAULT_QUERY_SET), ENV.fetch('EVAL_OUTPUT', DEFAULT_OUTPUT),
+       ENV.fetch('EVAL_BUDGET', DEFAULT_BUDGET.to_s).to_i]
+    end
 
-  runner = Woods::Evaluation::BaselineRunner.new(
-    metadata_store: Woods.metadata_store
-  )
+    # Build the thresholds hash for the release-quality gate, or nil for the
+    # report-only default (no gate). `EVAL_BASELINE_FILE` (the versioned
+    # baseline format, see Evaluation::Baseline) seeds it; the three flat
+    # EVAL_MIN_* vars override individual metrics on top, so a one-off CI run
+    # can tighten a single metric without a new baseline file.
+    #
+    # @return [Hash{Symbol=>Float}, nil]
+    def build_thresholds
+      path = ENV.fetch('EVAL_BASELINE_FILE', nil)
+      thresholds = path ? Evaluation::Baseline.load(path).thresholds : {}
+      thresholds[:mean_precision_at5] = ENV['EVAL_MIN_PRECISION'].to_f if ENV['EVAL_MIN_PRECISION']
+      thresholds[:mean_recall] = ENV['EVAL_MIN_RECALL'].to_f if ENV['EVAL_MIN_RECALL']
+      thresholds[:mean_mrr] = ENV['EVAL_MIN_MRR'].to_f if ENV['EVAL_MIN_MRR']
+      thresholds.empty? ? nil : thresholds
+    end
 
-  totals = compute_baseline_totals(query_set, runner, strategy, limit)
-  print_baseline_report(strategy, query_set.size, totals)
-end
+    # Score a naive baseline strategy on the same query set, for comparison.
+    #
+    # @param strategy [String, nil] grep, random, or file_level
+    # @return [void]
+    def run_baseline(strategy: nil)
+      require 'woods/mcp/bootstrapper'
+      require 'woods/evaluation/query_set'
+      require 'woods/evaluation/baseline_runner'
+      require 'woods/evaluation/metrics'
 
-def compute_baseline_totals(query_set, runner, strategy, limit)
-  total_mrr = 0.0
-  total_recall = 0.0
+      strategy = (strategy || ENV.fetch('EVAL_BASELINE_STRATEGY', 'grep')).to_sym
+      query_set_path = ENV.fetch('EVAL_QUERY_SET', DEFAULT_QUERY_SET)
+      limit = ENV.fetch('EVAL_BASELINE_LIMIT', DEFAULT_BASELINE_LIMIT.to_s).to_i
 
-  query_set.queries.each do |query|
-    results = runner.run(query.query, strategy: strategy, limit: limit)
-    total_mrr += Woods::Evaluation::Metrics.mrr(results, query.expected_units)
-    total_recall += Woods::Evaluation::Metrics.recall(results, query.expected_units)
-  end
+      puts "Loading query set from: #{query_set_path}"
+      query_set = Evaluation::QuerySet.load(query_set_path)
+      puts "Running #{strategy} baseline (limit: #{limit})..."
 
-  { mrr: total_mrr, recall: total_recall }
-end
+      runner = Evaluation::BaselineRunner.new(metadata_store: build_eval_retriever.metadata_store)
+      totals = compute_baseline_totals(query_set, runner, strategy, limit)
 
-def print_eval_report(report, output_path)
-  puts
-  puts 'Evaluation complete!'
-  puts '=' * 50
-  report.aggregates.each do |key, value|
-    formatted = value.is_a?(Float) ? format('%.4f', value) : value.to_s
-    puts "  #{key.to_s.ljust(25)}: #{formatted}"
-  end
-  puts '=' * 50
-  puts "Report saved to: #{output_path}"
-end
+      print_baseline_report(strategy, query_set.size, totals)
+    end
 
-def print_baseline_report(strategy, count, totals)
-  puts
-  puts "Baseline: #{strategy}"
-  puts '=' * 50
-  puts "  Mean MRR:    #{format('%.4f', count.positive? ? totals[:mrr] / count : 0.0)}"
-  puts "  Mean Recall: #{format('%.4f', count.positive? ? totals[:recall] / count : 0.0)}"
-  puts '=' * 50
-end
+    # @return [Hash] Summed MRR and recall across the query set
+    def compute_baseline_totals(query_set, runner, strategy, limit)
+      query_set.queries.each_with_object({ mrr: 0.0, recall: 0.0 }) do |query, totals|
+        results = runner.run(query.query, strategy: strategy, limit: limit)
+        totals[:mrr] += Evaluation::Metrics.mrr(results, query.expected_units)
+        totals[:recall] += Evaluation::Metrics.recall(results, query.expected_units)
+      end
+    end
 
-# Build a retriever for evaluation (requires Rails environment with stores configured).
-#
-# @return [Woods::Retriever]
-def build_eval_retriever
-  Woods::Retriever.new(
-    vector_store: Woods.vector_store,
-    metadata_store: Woods.metadata_store,
-    graph_store: Woods.graph_store,
-    embedding_provider: Woods.embedding_provider
-  )
+    # The configured retrieval pipeline, hydrated from persisted artifacts the
+    # same way the MCP server builds semantic search.
+    #
+    # @return [Woods::Retriever]
+    def build_eval_retriever
+      config = Woods.configuration || Woods.configure
+      retriever, _state = MCP::Bootstrapper.build_retriever(index_dir: config.output_dir)
+      retriever || raise(Woods::Error, 'Evaluation requires an embedded Woods index with a configured provider.')
+    end
+
+    def print_eval_report(report, output_path)
+      threshold_report = report.threshold_report
+      passed = threshold_report.nil? || threshold_report.passed
+      puts
+      puts(passed ? 'Evaluation complete!' : 'Evaluation FAILED — one or more thresholds not met.')
+      puts '=' * 50
+      report.aggregates.each do |key, value|
+        formatted = value.is_a?(Float) ? format('%.4f', value) : value.to_s
+        puts "  #{key.to_s.ljust(25)}: #{formatted}"
+      end
+      puts '=' * 50
+      print_threshold_report(threshold_report) if threshold_report
+      puts "Report saved to: #{output_path}"
+    end
+
+    # Per-metric [PASS]/[FAIL] lines with the delta against the configured
+    # minimum. Absent unconditionally, same as today, when no thresholds were
+    # given — see the "Evaluation complete!" gate above.
+    def print_threshold_report(threshold_report)
+      puts 'Thresholds:'
+      threshold_report.metrics.sort.each do |key, metric|
+        status = metric[:passed] ? '[PASS]' : '[FAIL]'
+        actual = metric[:actual].nil? ? 'n/a' : format('%.4f', metric[:actual])
+        delta = metric[:delta].nil? ? 'n/a' : format('%+.4f', metric[:delta])
+        puts "  #{status} #{key.to_s.ljust(25)} actual=#{actual} min=#{format('%.4f', metric[:threshold])} " \
+             "delta=#{delta}"
+      end
+      puts '=' * 50
+    end
+
+    def print_baseline_report(strategy, count, totals)
+      puts
+      puts "Baseline: #{strategy}"
+      puts '=' * 50
+      puts "  Mean MRR:    #{format('%.4f', count.positive? ? totals[:mrr] / count : 0.0)}"
+      puts "  Mean Recall: #{format('%.4f', count.positive? ? totals[:recall] / count : 0.0)}"
+      puts '=' * 50
+    end
+
+    # Run the agent-level ablation harness and write a JSON report. This
+    # collects paired on/off runs; it is not causal evidence, see
+    # docs/EVALUATION.md. Deliberately has no `:environment` prerequisite:
+    # the harness shells out to an agent command and never boots Rails.
+    #
+    # @param task_set_path [String, nil]
+    # @return [void]
+    def run_ablation(task_set_path: nil)
+      require 'woods/evaluation/ablation_task'
+      Evaluation::AblationTask.run(task_set_path: task_set_path, workdir: Dir.pwd)
+    end
+  end
 end

data/lib/woods/ast/call_site_extractor.rb

@@ -53,21 +53,6 @@ module Woods
         calls.sort_by { |c| c[:line] }
       end
 
-      # Extract only significant call sites, filtering out noise.
-      #
-      # @param node [Ast::Node] The AST node to search
-      # @param known_units [Array<String>] Known unit identifiers for relevance filtering
-      # @return [Array<Hash>] Filtered call site hashes
-      def extract_significant(node, known_units: [])
-        calls = extract(node)
-        known_set = Set.new(known_units)
-
-        calls.reject do |call|
-          INSIGNIFICANT_METHODS.include?(call[:method_name]) &&
-            (known_units.empty? || !known_set.include?(call[:receiver]))
-        end
-      end
-
       private
 
       def collect_calls(node, calls)
@@ -94,6 +79,12 @@ module Woods
               block: true
             }
           end
+          # Recurse into the send's own children — its receiver chain and its
+          # arguments — the way the non-block :send branch does (EXTB-16).
+          # Skipping them lost `where` from `User.where(active: true).each {}`
+          # while the same chain without a block recorded it. The send itself
+          # is emitted above, so recursing into its children adds no duplicate.
+          send_child.children&.each { |child| collect_calls(child, calls) } if send_child.is_a?(Ast::Node)
           # Also recurse into block body (children[1])
           node.children&.drop(1)&.each { |child| collect_calls(child, calls) }
           return # Don't double-recurse into children

data/lib/woods/ast/method_extractor.rb

@@ -38,15 +38,6 @@ module Woods
         end
       end
 
-      # Extract all method definition nodes from source.
-      #
-      # @param source [String] Ruby source code
-      # @return [Array<Ast::Node>] All :def and :defs nodes
-      def extract_all_methods(source)
-        root = @parser.parse(source)
-        root.find_all(:def) + root.find_all(:defs)
-      end
-
       # Extract the raw source text of a method, including def...end.
       #
       # This is the key replacement for `extract_action_source` in the controller
@@ -66,6 +57,25 @@ module Woods
         # Fallback: extract by line range
         extract_source_span(source, node.line, node.end_line)
       end
+
+      # Extract the raw source text of every instance-method definition,
+      # keyed by method name — one parse answers every query (P1).
+      #
+      # A name defined more than once keeps its first definition, matching
+      # {#extract_method_source}'s first-match lookup, so
+      # `extract_method_sources(source)[name]` is byte-identical to
+      # `extract_method_source(source, name)` for every name.
+      #
+      # @param source [String] Ruby source code
+      # @return [Hash{String => String}] method name => source text
+      def extract_method_sources(source)
+        root = @parser.parse(source)
+        root.find_all(:def).each_with_object({}) do |node, map|
+          next if map.key?(node.method_name)
+
+          map[node.method_name] = node.source || extract_source_span(source, node.line, node.end_line)
+        end
+      end
     end
   end
 end

data/lib/woods/ast/parser.rb

@@ -277,7 +277,13 @@ module Woods
 
         # Convert receiver node so tree walking finds nested calls/constants
         receiver_node = prism_node.receiver ? convert_prism_node(prism_node.receiver, source) : nil
-        children = [receiver_node].compact
+        # Argument nodes become children too (EXTB-5). Flattening arguments to
+        # source text alone hid every definition and call nested in an argument
+        # list — `private def hidden` lost the whole method, `foo(Bar.baz)` lost
+        # the `Bar.baz` call site. The `arguments` text field is unchanged for
+        # existing consumers; the children are appended *after* the receiver so
+        # nothing that reads children[0] as the receiver moves.
+        children = [receiver_node].compact + convert_prism_arguments(prism_node, source)
 
         # If there's a block, create a :block node wrapping this send
         if prism_node.block.is_a?(Prism::BlockNode)
@@ -311,8 +317,22 @@ module Woods
         )
       end
 
+      # Convert a call's argument nodes into walkable children.
+      #
+      # Only {Node} results are kept: literals convert to bare Strings or
+      # Integers, which carry nothing for a tree walker and would only make
+      # the children array noisier.
+      def convert_prism_arguments(prism_node, source)
+        return [] unless prism_node.arguments
+
+        prism_node.arguments.arguments.filter_map do |arg|
+          converted = convert_prism_node(arg, source)
+          converted if converted.is_a?(Node)
+        end
+      end
+
       def convert_prism_constant_path(prism_node, _source)
-        parent_text = (extract_const_path_text(prism_node.parent) if prism_node.parent)
+        parent_text = prism_node.parent ? extract_const_path_text(prism_node.parent) : ''
         const_name = prism_node.respond_to?(:name) ? prism_node.name.to_s : prism_node.child.name.to_s
 
         Node.new(
@@ -331,13 +351,30 @@ module Woods
           condition = Node.new(**condition.to_h, source: condition_source)
         end
 
-        then_body = prism_node.statements ? convert_prism_node(prism_node.statements, source) : nil
+        body = prism_node.statements ? convert_prism_node(prism_node.statements, source) : nil
         else_clause = prism_else_clause(prism_node)
         else_body = else_clause ? convert_prism_node(else_clause, source) : nil
 
+        # `unless` runs its body when the predicate is FALSE, so the body
+        # belongs in the else slot and the else clause in the then slot
+        # (EXTB-4). Sharing the unswapped :if shape made every flow document
+        # state the opposite of what the code does. After the swap the emitted
+        # `if <predicate>` reading is exact, so no negation marker is needed —
+        # the parser-gem branch below already normalizes `unless` the same way.
+        then_body, else_body = if prism_node.is_a?(Prism::UnlessNode)
+                                 [else_body, body]
+                               else
+                                 [body, else_body]
+                               end
+
         Node.new(
           type: :if,
-          children: [condition, then_body, else_body].compact,
+          # Positional: [condition, then, else]. NO compact — a missing slot
+          # must stay a nil hole. A literal `nil` condition converts to nil
+          # (the NilNode mapping below), and compacting shifted the else body
+          # into children[1], which handle_conditional reported as then_ops
+          # (L2). Every consumer guards with `is_a?(Ast::Node)`.
+          children: [condition, then_body, else_body],
           line: line_for_prism(prism_node),
           end_line: end_line_for_prism(prism_node),
           source: condition_source
@@ -345,8 +382,13 @@ module Woods
       end
 
       def convert_prism_case(prism_node, source)
-        children = []
-        children << convert_prism_node(prism_node.predicate, source) if prism_node.predicate
+        # Positional: [predicate, *branches]. The predicate slot stays a nil
+        # hole for a predicate-less `case` (EXTB-15) — omitting it shifted the
+        # first `when` into children[0], where every consumer's `drop(1)` threw
+        # the branch away and rendered its condition as the word "when".
+        # Mirrors the L2 convention in {#convert_prism_if}.
+        predicate = (convert_prism_node(prism_node.predicate, source) if prism_node.predicate)
+        children = [predicate]
         prism_node.conditions.each { |c| children << convert_prism_node(c, source) }
         else_clause = prism_else_clause(prism_node)
         children << convert_prism_node(else_clause, source) if else_clause
@@ -428,7 +470,7 @@ module Woods
         when Prism::ConstantReadNode
           node.name.to_s
         when Prism::ConstantPathNode
-          parent = node.parent ? extract_const_path_text(node.parent) : nil
+          parent = node.parent ? extract_const_path_text(node.parent) : ''
           const_name = node.respond_to?(:name) ? node.name.to_s : node.child.name.to_s
           [parent, const_name].compact.join('::')
         end
@@ -529,7 +571,9 @@ module Woods
           else_body = parser_node.children[2] ? convert_parser_node(parser_node.children[2], source) : nil
           Node.new(
             type: :if,
-            children: [condition, then_body, else_body].compact,
+            # Positional [condition, then, else] with nil holes — see the
+            # Prism branch of convert_prism_if (L2).
+            children: [condition, then_body, else_body],
             line: parser_node.loc.line,
             end_line: parser_node.loc.expression&.last_line,
             source: condition_source
@@ -604,6 +648,8 @@ module Woods
         return nil unless node.is_a?(::Parser::AST::Node)
 
         case node.type
+        when :cbase
+          ''
         when :const
           parent = node.children[0] ? extract_parser_const_name(node.children[0]) : nil
           [parent, node.children[1].to_s].compact.join('::')