dogfood 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93baf06e414b181624c84decd7ba9fb434c983cbdb72c46c98fed78e597ff1c3
-  data.tar.gz: 2d8cc07a607a74be6fa67f1e04279e3e600c250230b6ec3accfea0f6afd1a3a8
+  metadata.gz: 5f3da6c7dfbeb9f09325d741ae81a835d65da453a17f5ca6deeb3cfde8826f73
+  data.tar.gz: 258a2ad0661d1aa5234e18305f75a39a0a696f8108fdef39988299db8e07d709
 SHA512:
-  metadata.gz: 480f7e8463937d4f2ea1ba4f393dd2b816956898cc9f70db90d9c3477d624519c0ad3728a0d98f34f7769aec2efe60c6c0f427046b2a3f9dd603f89cb5acb0bd
-  data.tar.gz: ff98caf2d27c13948dc4b87097502f85e5cbe3ed979545a919cb33cd467ad9655cefef852c5d97e113b7a576680ae3771f581ea5ab1be1db2ee1ad6063b3ae19
+  metadata.gz: a6f7f694fbad5f13ff0d058eb819b005bc0cbd3464a3a692d022273759ec5f55bdc38e2206d99d2221fd458db732f948929d47949feccb44ddf2a210191fa624
+  data.tar.gz: 5a23dcbaf64043a23160180459ec1cf73fb39ac83adb630bd010affb36e42303c6f1edc7609c5193e7a30e31583ae8bd6fab845b4ed323385a9c31195de72d69

data/bin/dogfood

@@ -1,5 +1,13 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
 require "dogfood"
-Dogfood::CLI.new(ARGV).run
+cli = Dogfood::CLI.new(ARGV)
+begin
+  cli.run
+rescue Dogfood::CLI::UsageError => e
+  warn "Error: #{e.message}"
+  cli.print_help
+  exit 1
+end

data/lib/dogfood/cli.rb

@@ -4,13 +4,14 @@ require "fileutils"
 
 module Dogfood
   class CLI
+    UsageError = Class.new(StandardError)
+
     def initialize(argv)
       @argv = argv
       @options = {
         output: default_output_path,
         days: 1,
-        wo_per_day: (3..6),
-        fleet_ratio: 0.25,
+        stories_per_day: (3..6),
         seed: nil,
         scenario: nil
       }
@@ -26,10 +27,9 @@ module Dogfood
         return
       end
 
-      unless @options[:pack]
-        warn "Error: --pack PATH is required"
-        print_help
-        exit 1
+      @options[:pack] ||= default_pack_path
+      unless @options[:pack] && File.exist?(@options[:pack])
+        raise UsageError, "no --pack given and no config/dogfood.rb found in the current directory"
       end
 
       load_pack(@options[:pack])
@@ -40,7 +40,8 @@ module Dogfood
       end
 
       if @options[:explain]
-        explain_file(@options[:explain])
+        target = @options[:explain] == true ? @options[:scenario] : @options[:explain]
+        explain(target)
         return
       end
 
@@ -52,8 +53,7 @@ module Dogfood
       generator = Dogfood::DayGenerator.new(
         pack: Dogfood::Pack.current,
         days: @options[:days],
-        wo_per_day: @options[:wo_per_day],
-        fleet_ratio: @options[:fleet_ratio],
+        stories_per_day: @options[:stories_per_day],
         seed: @options[:seed],
         scenario: @options[:scenario]
       )
@@ -82,8 +82,13 @@ module Dogfood
         when "--list", "-l"
           @options[:list] = true
         when "--explain"
-          @options[:explain] = @argv[i + 1]
-          i += 1
+          val = @argv[i + 1]
+          if val && !val.start_with?("-")
+            @options[:explain] = val
+            i += 1
+          else
+            @options[:explain] = true
+          end
         when "--dry-run"
           @options[:dry_run] = true
         when "--random", "-r"
@@ -91,11 +96,8 @@ module Dogfood
         when /^--days(?:=(.+))?$/
           @options[:days] = ($1 || @argv[i + 1]).to_i
           i += 1 unless $1
-        when /^--wo-per-day(?:=(.+))?$/
-          @options[:wo_per_day] = parse_wo_per_day($1 || @argv[i + 1])
-          i += 1 unless $1
-        when /^--fleet-ratio(?:=(.+))?$/
-          @options[:fleet_ratio] = ($1 || @argv[i + 1]).to_f
+        when /^--stories-per-day(?:=(.+))?$/
+          @options[:stories_per_day] = parse_stories_per_day($1 || @argv[i + 1])
           i += 1 unless $1
         when /^--seed(?:=(.+))?$/
           @options[:seed] = ($1 || @argv[i + 1]).to_i
@@ -105,11 +107,39 @@ module Dogfood
           i += 1 unless $1
         when "--help", "-h"
           @options[:help] = true
+        else
+          @options[:scenario] ||= arg
         end
         i += 1
       end
     end
 
+    def print_help
+      puts <<~HELP
+        Usage: dogfood [options] [scenario_name]
+
+          --pack PATH              Ruby file that registers a Dogfood::Pack
+                                   (default: config/dogfood.rb in the current directory)
+          --scenario NAME          Run a specific named scenario (otherwise: random mix)
+          --days N                 Number of simulated days (default: 1)
+          --stories-per-day N or M-N  Stories per day (default: 3-6)
+          --seed N                 Set random seed for reproducibility
+          --random                 Use a random seed (prints it)
+          --output PATH, -o PATH   Output file path (default: tmp/dogfood/<timestamp>.md)
+          --list, -l               List available scenarios
+          --explain [NAME|FILE]    Print the stage/decision tree for a scenario name
+                                   or YAML file, no RNG
+          --dry-run --scenario NAME  Same as --explain NAME
+          --help, -h               Show help
+
+        Examples:
+          dogfood --list
+          dogfood --explain supplemental_authorization
+          dogfood supplemental_authorization --explain
+          dogfood --scenario brake_repair_with_parts_order --days 3
+      HELP
+    end
+
     private
 
     def load_pack(path)
@@ -118,7 +148,12 @@ module Dogfood
       raise "Pack file did not set Dogfood::Pack.current" unless Dogfood::Pack.current
     end
 
-    def parse_wo_per_day(value)
+    def default_pack_path
+      path = File.expand_path("config/dogfood.rb", Dir.pwd)
+      File.exist?(path) ? path : nil
+    end
+
+    def parse_stories_per_day(value)
       if value.include?("-")
         min, max = value.split("-").map(&:to_i)
         (min..max)
@@ -129,8 +164,28 @@ module Dogfood
 
     def list_scenarios
       puts "Available scenarios:"
-      Dogfood::Pack.current.scenario_keys.each do |key|
-        puts "  - #{key}"
+      Dogfood::Pack.current.scenarios.each do |key, klass|
+        type = klass.respond_to?(:compiled_ast) ? "YAML" : "Ruby"
+        title = safe_title(klass)
+        puts "  %-40s [%s]  %s" % [key, type, title]
+      end
+    end
+
+    def safe_title(klass)
+      klass.new(rng: Dogfood::Randomness.new(seed: 0), id: "S-000").title
+    rescue StandardError
+      ""
+    end
+
+    def explain(target)
+      if target.nil?
+        raise UsageError, "--explain needs a scenario name or a YAML file path"
+      end
+
+      if File.exist?(target) || target.end_with?(".yml", ".yaml")
+        explain_file(target)
+      else
+        explain_scenario(target)
       end
     end
 
@@ -139,14 +194,14 @@ module Dogfood
       yaml = YAML.load_file(path)
       Dogfood::DSL::Schema.validate!(yaml)
       klass = Dogfood::DSL::Compiler.compile(yaml, pack: Dogfood::Pack.current)
-      puts Dogfood::DSL::ExplainRenderer.new(klass.compiled_ast).render
+      puts Dogfood::DSL::AuditRenderer.new(klass.compiled_ast, pack: Dogfood::Pack.current).render
     end
 
     def explain_scenario(name)
       klass = Dogfood::Pack.current.find_scenario(name)
 
       if klass.respond_to?(:compiled_ast)
-        puts Dogfood::DSL::ExplainRenderer.new(klass.compiled_ast).render
+        puts Dogfood::DSL::AuditRenderer.new(klass.compiled_ast, pack: Dogfood::Pack.current).render
       else
         puts render_ruby_story(name, klass)
       end
@@ -157,7 +212,7 @@ module Dogfood
     def render_ruby_story(name, klass)
       lines = []
       lines << "Scenario: #{name}"
-      lines << "Title: #{klass.new(rng: Dogfood::Randomness.new(seed: 0), id: 'WO-000').title}"
+      lines << "Title: #{klass.new(rng: Dogfood::Randomness.new(seed: 0), id: 'S-000').title}"
       lines << "Type: Ruby story class"
       lines << ""
       lines << "This scenario is implemented as a Ruby class (#{klass.name}) rather than a YAML file."
@@ -169,24 +224,5 @@ module Dogfood
       timestamp = Time.now.strftime("%Y-%m-%d-%H%M%S")
       "tmp/dogfood/#{timestamp}-dogfood.md"
     end
-
-    def print_help
-      puts <<~HELP
-        Usage: dogfood [options]
-
-          --pack PATH              Ruby file that registers a Dogfood::Pack (required)
-          --scenario NAME          Run a specific named scenario (otherwise: random mix)
-          --days N                 Number of simulated days (default: 1)
-          --wo-per-day N or M-N    Work orders per day (default: 3-6)
-          --fleet-ratio RATIO      Fraction of fleet stories (default: 0.25)
-          --seed N                 Set random seed for reproducibility
-          --random                 Use a random seed (prints it)
-          --output PATH, -o PATH   Output file path (default: tmp/dogfood/<timestamp>.md)
-          --list, -l               List available scenarios
-          --explain FILE           Compile FILE and print the stage/decision tree, no RNG
-          --dry-run --scenario N   Same as --explain but takes a registered name
-          --help, -h               Show help
-      HELP
-    end
   end
 end

data/lib/dogfood/day_generator.rb

@@ -4,14 +4,13 @@ require "date"
 
 module Dogfood
   class DayGenerator
-    DEFAULTS = { days: 1, wo_per_day: (3..6), fleet_ratio: 0.25, seed: nil }.freeze
+    DEFAULTS = { days: 1, stories_per_day: (3..6), seed: nil }.freeze
 
-    def initialize(pack:, days: nil, wo_per_day: nil, fleet_ratio: nil, seed: nil, scenario: nil)
+    def initialize(pack:, days: nil, stories_per_day: nil, seed: nil, scenario: nil)
       @pack = pack
       @config = DEFAULTS.dup
       @config[:days] = days if days
-      @config[:wo_per_day] = wo_per_day if wo_per_day
-      @config[:fleet_ratio] = fleet_ratio if fleet_ratio
+      @config[:stories_per_day] = stories_per_day if stories_per_day
       @config[:seed] = seed if seed
       @scenario = scenario&.to_sym
       @rng = Dogfood::Randomness.new(seed: @config[:seed])
@@ -54,10 +53,10 @@ module Dogfood
     end
 
     def build_new_stories(day_index, carry_over_count)
-      target = wo_count_for_day
+      target = story_count_for_day
       count = [target - carry_over_count, 0].max
       count.times.map do
-        story = @builder.build(fleet_ratio: @config[:fleet_ratio], include: @scenario)
+        story = @builder.build(include: @scenario)
         @ledger.register({ story: story, id: story.id, status: :estimate })
         story
       end
@@ -76,8 +75,8 @@ module Dogfood
       end
     end
 
-    def wo_count_for_day
-      range = @config[:wo_per_day]
+    def story_count_for_day
+      range = @config[:stories_per_day]
       range.is_a?(Range) ? @rng.rand(range) : range
     end
 

data/lib/dogfood/dsl/audit_renderer.rb

@@ -0,0 +1,396 @@
+# frozen_string_literal: true
+
+module Dogfood
+  module DSL
+    # Produces a five-section audit report for `--explain`:
+    #   A. Stage/decision tree (delegates to ExplainRenderer)
+    #   B. Branch weight table
+    #   C. Path enumeration (full step sequences per path)
+    #   D. Edge-case gap detection
+    #   E. Step resolution check
+    class AuditRenderer
+      MAX_PATHS = 50
+
+      def initialize(ast, pack: nil)
+        @ast = ast
+        @pack = pack
+      end
+
+      def render
+        lines = []
+        lines.concat(section_a)
+        lines << ""
+        lines.concat(section_b)
+        lines << ""
+        lines.concat(section_c)
+        lines << ""
+        lines.concat(section_d)
+        lines << ""
+        lines.concat(section_e)
+        lines.join("\n") + "\n"
+      end
+
+      private
+
+      # ── Section A: Stage/decision tree ──
+
+      def section_a
+        ExplainRenderer.new(@ast).render.split("\n")
+      end
+
+      # ── Section B: Branch weight table ──
+
+      def section_b
+        lines = ["## Branch weights"]
+        any = false
+
+        @ast[:stages].each do |stage|
+          weights = stage[:branch_weights]
+          next unless weights
+
+          any = true
+          lines << ""
+          lines << "Stage: #{stage[:stage]}"
+          max_label = weights.keys.map(&:length).max
+          weights.each do |label, weight|
+            bar = bar_for(weight, weights.values.max)
+            lines << "  %-#{max_label}s  %.2f  %s" % [label, weight, bar]
+          end
+        end
+
+        # Surface when/maybe probabilities
+        when_probs = collect_conditional_probs
+        unless when_probs.empty?
+          any = true
+          lines << ""
+          lines << "Conditionals:"
+          when_probs.each do |desc|
+            lines << "  #{desc}"
+          end
+        end
+
+        lines << "" unless any
+        lines << "  (no branches or conditionals)" unless any
+        lines
+      end
+
+      def bar_for(weight, max_weight)
+        scale = (weight.to_f / max_weight * 20).round
+        "█" * scale
+      end
+
+      def collect_conditional_probs
+        probs = []
+        @ast[:stages].each do |stage|
+          stage[:steps].each do |step|
+            case step[:type]
+            when :maybe
+              probs << "maybe #{step[:prob]} in stage #{stage[:stage]}"
+            when :when
+              # Try to find a chance_decline or similar in the preceding call's with:
+              expr = step[:expr]
+              probs << "when #{expr} in stage #{stage[:stage]}"
+            end
+          end
+        end
+        probs
+      end
+
+      # ── Section C: Path enumeration ──
+
+      def section_c
+        lines = ["## Path enumeration"]
+        paths = enumerate_paths
+
+        if paths.length > MAX_PATHS
+          lines << ""
+          lines << "  ⚠ #{paths.length} paths total (showing first #{MAX_PATHS})"
+          paths = paths.first(MAX_PATHS)
+        end
+
+        paths.each_with_index do |path, idx|
+          lines << ""
+          label = path[:branches].empty? ? "(linear)" : path[:branches].join(" → ")
+          lines << "Path #{idx + 1}: #{label}"
+          path[:steps].each_with_index do |step, s_idx|
+            lines << "  #{s_idx + 1}. #{step}"
+          end
+          terminal = path[:terminal] || "unknown"
+          lines << "  Terminal: #{terminal}"
+        end
+
+        lines
+      end
+
+      def enumerate_paths
+        paths = []
+        walk_stages(@ast[:stages], 0, [], [], { status: :estimate, substatus: nil }, paths)
+        paths
+      end
+
+      # Walks stages recursively. state tracks known @state for when-condition pruning.
+      def walk_stages(stages, stage_idx, current_steps, branch_labels, state, paths)
+        if stage_idx >= stages.length
+          paths << { branches: branch_labels.dup, steps: current_steps.dup, terminal: "#{state[:status]} / #{state[:substatus] || '-'}" }
+          return
+        end
+
+        stage = stages[stage_idx]
+        weights = stage[:branch_weights]
+
+        if weights
+          weights.each_key do |branch_label|
+            filtered = filter_branch_steps(stage[:steps], branch_label)
+            new_branch_labels = branch_labels + [branch_label]
+            expand_steps(filtered, stage, stages, stage_idx, current_steps, new_branch_labels, state, paths)
+          end
+        else
+          expand_steps(stage[:steps], stage, stages, stage_idx, current_steps, branch_labels, state, paths)
+        end
+      end
+
+      def expand_steps(steps, stage, stages, stage_idx, current_steps, branch_labels, state, paths)
+        fork_expansion(steps, 0, stage, stages, stage_idx, current_steps, branch_labels, state, paths)
+      end
+
+      def fork_expansion(steps, step_idx, stage, stages, stage_idx, current_steps, branch_labels, state, paths)
+        if step_idx >= steps.length
+          walk_stages(stages, stage_idx + 1, current_steps, branch_labels, state, paths)
+          return
+        end
+
+        step = steps[step_idx]
+        case step[:type]
+        when :call
+          new_steps = current_steps + [format_path_step(step)]
+          new_state = step[:name] == :update_state ? merge_state(state, step[:with]) : state
+          fork_expansion(steps, step_idx + 1, stage, stages, stage_idx, new_steps, branch_labels, new_state, paths)
+        when :when
+          result = eval_when_static(step[:expr], state)
+          if result == true
+            expand_block(step[:then], steps, step_idx + 1, stage, stages, stage_idx, current_steps, branch_labels + ["then"], state, paths)
+          elsif result == false
+            expand_block(step[:else] || [], steps, step_idx + 1, stage, stages, stage_idx, current_steps, branch_labels + ["else"], state, paths)
+          else
+            expand_block(step[:then], steps, step_idx + 1, stage, stages, stage_idx, current_steps, branch_labels + ["then"], state, paths)
+            expand_block(step[:else] || [], steps, step_idx + 1, stage, stages, stage_idx, current_steps, branch_labels + ["else"], state, paths)
+          end
+        when :maybe
+          expand_block(step[:then], steps, step_idx + 1, stage, stages, stage_idx, current_steps, branch_labels + ["maybe"], state, paths)
+          fork_expansion(steps, step_idx + 1, stage, stages, stage_idx, current_steps, branch_labels, state, paths)
+        end
+      end
+
+      # Expands a block (then/else/maybe) which may contain :call and :maybe steps.
+      # After the block, continues with the remaining steps in the parent list.
+      def expand_block(block_steps, parent_steps, parent_idx, stage, stages, stage_idx, current_steps, branch_labels, state, paths)
+        if block_steps.empty?
+          fork_expansion(parent_steps, parent_idx, stage, stages, stage_idx, current_steps, branch_labels, state, paths)
+          return
+        end
+
+        block_steps.each_with_index do |bstep, bidx|
+          case bstep[:type]
+          when :call
+            current_steps = current_steps + [format_path_step(bstep)]
+            new_state = bstep[:name] == :update_state ? merge_state(state, bstep[:with]) : state
+            if bidx == block_steps.length - 1
+              fork_expansion(parent_steps, parent_idx, stage, stages, stage_idx, current_steps, branch_labels, new_state, paths)
+            else
+              state = new_state
+            end
+          when :maybe
+            # Fork: with maybe and without
+            if bidx == block_steps.length - 1
+              # Last item in block — fork then continue parent
+              expand_block(bstep[:then], parent_steps, parent_idx, stage, stages, stage_idx, current_steps, branch_labels + ["maybe"], state, paths)
+              fork_expansion(parent_steps, parent_idx, stage, stages, stage_idx, current_steps, branch_labels, state, paths)
+            else
+              # Not last — need to fork and continue remaining block steps
+              # with maybe
+              expand_block_remainder(bstep[:then], block_steps, bidx + 1, parent_steps, parent_idx, stage, stages, stage_idx, current_steps, branch_labels + ["maybe"], state, paths)
+              # without maybe
+              expand_block_remainder([], block_steps, bidx + 1, parent_steps, parent_idx, stage, stages, stage_idx, current_steps, branch_labels, state, paths)
+            end
+            return
+          end
+        end
+      end
+
+      # Expands remainder of a block after a fork, then continues parent.
+      def expand_block_remainder(extra_steps, block_steps, start_idx, parent_steps, parent_idx, stage, stages, stage_idx, current_steps, branch_labels, state, paths)
+        remaining = extra_steps + block_steps[start_idx..]
+        expand_block(remaining, parent_steps, parent_idx, stage, stages, stage_idx, current_steps, branch_labels, state, paths)
+      end
+
+      def merge_state(state, with_hash)
+        state.merge(
+          status: with_hash["status"]&.to_sym || state[:status],
+          substatus: with_hash.key?("substatus") ? with_hash["substatus"] : state[:substatus]
+        )
+      end
+
+      # Returns true/false if the when condition can be statically resolved, nil if unknown.
+      def eval_when_static(expr, state)
+        # Match ${state.status == :symbol} or ${state.status != :symbol}
+        return nil unless expr.is_a?(String)
+
+        if expr =~ /\$\{\s*state\.status\s*==\s*:(\w+)\s*\}/
+          return state[:status].to_s == $1
+        elsif expr =~ /\$\{\s*state\.status\s*!=\s*:(\w+)\s*\}/
+          return state[:status].to_s != $1
+        end
+        nil
+      end
+
+      def filter_branch_steps(steps, branch_label)
+        # Steps with when_branch matching the label, plus steps with no when_branch (merge steps)
+        steps.select do |s|
+          case s[:type]
+          when :call
+            s[:when_branch].nil? || s[:when_branch] == branch_label
+          else
+            true
+          end
+        end
+      end
+
+      def format_path_step(step)
+        args = step[:with] || {}
+        arg_str = args.empty? ? "" : " (#{args.map { |k, v| "#{k}: #{format_val(v)}" }.join(', ')})"
+        out_str = step[:out] ? " → out: #{step[:out]}" : ""
+        "#{step[:name]}#{arg_str}#{out_str}"
+      end
+
+      def format_val(v)
+        case v
+        when Hash then "{...}"
+        when Array then "[...]"
+        else v.to_s
+        end
+      end
+
+      # ── Section D: Edge-case gap detection ──
+
+      def section_d
+        lines = ["## Coverage gaps"]
+        gaps = detect_gaps
+
+        if gaps.empty?
+          lines << ""
+          lines << "  (no gaps detected)"
+        else
+          gaps.each { |g| lines << "  ⚠ #{g}" }
+        end
+
+        lines
+      end
+
+      def detect_gaps
+        gaps = []
+
+        @ast[:stages].each do |stage|
+          has_branches = !!stage[:branch_weights]
+          has_when = stage[:steps].any? { |s| s[:type] == :when }
+          has_maybe = stage[:steps].any? { |s| s[:type] == :maybe } ||
+                      stage[:steps].any? { |s| s[:type] == :when && s[:then].any? { |c| c[:type] == :maybe } }
+
+          unless has_branches || has_when || has_maybe
+            gaps << "stage \"#{stage[:stage]}\" has no branches or conditionals (linear)"
+          end
+
+          unless has_maybe
+            gaps << "stage \"#{stage[:stage]}\" has no maybe/error path"
+          end
+
+          # when blocks with no else
+          stage[:steps].each do |step|
+            if step[:type] == :when && (step[:else].nil? || step[:else].empty?)
+              gaps << "stage \"#{stage[:stage]}\" has a when block with no else"
+            end
+          end
+        end
+
+        # Check if all paths terminate in the same status
+        paths = enumerate_paths
+        terminals = paths.map { |p| p[:terminal] }.uniq
+        if terminals.length == 1 && terminals.first != "unknown"
+          gaps << "all paths terminate in \"#{terminals.first}\" — no alternative outcomes"
+        end
+
+        gaps
+      end
+
+      # ── Section E: Step resolution check ──
+
+      def section_e
+        lines = ["## Step resolution"]
+        names = collect_all_call_names.uniq
+
+        if names.empty?
+          lines << ""
+          lines << "  (no calls)"
+          return lines
+        end
+
+        builtins = Dogfood::DSL::Compiler::BUILTIN_NAMES
+        max_name = names.map(&:length).max
+
+        names.each do |name|
+          if builtins.include?(name)
+            lines << "  %-#{max_name}s  ✓ builtin" % name
+          elsif @pack && resolves_in_pack?(name)
+            mod = find_pack_module(name)
+            lines << "  %-#{max_name}s  ✓ pack (%s)" % [name, mod]
+          else
+            lines << "  %-#{max_name}s  ✗ missing" % name
+          end
+        end
+
+        if @pack && !@pack.pools.empty?
+          lines << ""
+          lines << "Pools:"
+          @pack.pools.sort_by { |name, _| name.to_s }.each do |name, pool|
+            lines << "  #{name} (#{pool.all.length} entries)"
+          end
+        end
+
+        lines
+      end
+
+      def resolves_in_pack?(name)
+        return false unless @pack
+        @pack.step_modules.any? { |m| m.instance_methods.include?(name) } ||
+          @pack.mixin_modules.any? { |m| m.instance_methods.include?(name) }
+      end
+
+      def find_pack_module(name)
+        return "unknown" unless @pack
+        mod = (@pack.step_modules + @pack.mixin_modules).find { |m| m.instance_methods.include?(name) }
+        mod&.name || "anonymous"
+      end
+
+      def collect_all_call_names
+        names = []
+        @ast[:stages].each do |stage|
+          stage[:steps].each do |step|
+            collect_step_names(step, names)
+          end
+        end
+        names
+      end
+
+      def collect_step_names(step, names)
+        case step[:type]
+        when :call
+          names << step[:name]
+        when :when
+          step[:then].each { |c| collect_step_names(c, names) }
+          (step[:else] || []).each { |c| collect_step_names(c, names) }
+        when :maybe
+          step[:then].each { |c| collect_step_names(c, names) }
+        end
+      end
+    end
+  end
+end