woods 2.0.0.beta2 → 2.0.0.beta3

data/lib/woods/extractors/service_extractor.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../source_inputs/consumer_errors'
+
 require_relative 'shared_utility_methods'
 require_relative 'shared_dependency_scanner'
 require_relative 'source_nesting'
@@ -83,7 +85,7 @@ module Woods
 
         unit
       rescue StandardError => e
-        Rails.logger.error("Failed to extract service #{file_path}: #{e.message}")
+        SourceInputs::ConsumerErrors.log(self, "Failed to extract service #{file_path}: #{e.message}")
         nil
       end
 

data/lib/woods/extractors/shared_dependency_scanner.rb

@@ -204,8 +204,8 @@ module Woods
       # Match _path/_url route helpers anywhere in source.
       # This intentionally matches all usages (assignments, string interpolation, etc.)
       # not just link_to/redirect_to calls — any reference to a route helper indicates
-      # a dependency on that controller. False positives from non-route _path/_url
-      # suffixes (file_path, base_url, etc.) are filtered by RouteHelperResolver::IGNORED_HELPER_PREFIXES.
+      # a dependency on that controller. RouteHelperResolver accepts only names
+      # present in the live controller/action route map, excluding unknown helpers.
       # Requires the including class to also include RouteHelperResolver
       # and call build_route_helper_map in its initializer.
       ROUTE_HELPER_PATTERN = /\b(\w+)_(path|url)\b/

data/lib/woods/extractors/shared_utility_methods.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'source_nesting'
+require_relative 'method_parameters'
 
 module Woods
   module Extractors
@@ -221,6 +222,29 @@ module Woods
         actions.to_a
       end
 
+      # Rails 6 exposes a numeric Proc identity through #filter, and the
+      # callable through #raw_filter. Newer Rails exposes the callable directly.
+      def callback_filter(callback)
+        stable_filter(callback.respond_to?(:raw_filter) ? callback.raw_filter : callback.filter)
+      end
+
+      # Proc#to_s embeds a process-local address. Model and controller filters
+      # share source-site labels, so metadata and derived chunks agree across
+      # boots. Preserve symbols and other application-defined callback values.
+      def stable_filter(filter)
+        return filter unless filter.is_a?(Proc)
+
+        location = filter.source_location
+        site = if location
+                 path, line = location
+                 "#{path.delete_prefix("#{Rails.root}/")}:#{line}"
+               else
+                 'native'
+               end
+        "#<#{filter.lambda? ? 'lambda' : 'Proc'} #{site}>"
+      end
+      private :callback_filter, :stable_filter
+
       # Human-readable label for a non-ActionFilter condition.
       #
       # @param condition [Object] A proc, symbol, or other condition
@@ -292,7 +316,7 @@ module Woods
         source.scan(/def\s+self\.(\w+[?!=]?)/).flatten
       end
 
-      # Extract initialize parameters from source code via regex.
+      # Extract initialize parameters from source syntax without evaluating defaults.
       #
       # Parses the parameter list of the initialize method to determine
       # parameter names, defaults, and whether they are keyword arguments.
@@ -304,21 +328,9 @@ module Woods
       # @param source [String] Ruby source code
       # @return [Array<Hash>] Parameter info hashes with :name, :has_default, :keyword
       def extract_initialize_params(source)
-        init_match = source.match(/def\s+initialize\s*\((.*?)\)/m)
-        return [] unless init_match
-
-        params_str = init_match[1]
-        params = []
-
-        params_str.scan(/(\w+)(?::\s*([^,\n]+))?/) do |name, default|
-          params << {
-            name: name,
-            has_default: !default.nil?,
-            keyword: params_str.include?("#{name}:")
-          }
+        MethodParameters.extract(source, :initialize).map do |parameter|
+          parameter.slice(:name, :has_default, :keyword)
         end
-
-        params
       end
     end
   end

data/lib/woods/extractors/source_nesting.rb

@@ -245,7 +245,7 @@ module Woods
       # The constant path the active main loader expects for +file_path+,
       # asked through the loader's own API so its inflector, namespace
       # collapse, and ignore rules decide (a custom `api => API` inflection
-      # must win over the local camelizer). Available on Zeitwerk 2.6.4+;
+      # must win over the local camelizer). Available on Zeitwerk 2.6.9+;
       # nil — unmanaged — when the loader's API is older, declines the
       # file, or cannot derive a name. A decline is authoritative: the
       # local camelizer must not rescue it.

data/lib/woods/extractors/state_machine_extractor.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../source_inputs/consumer_errors'
+
 require_relative 'shared_utility_methods'
 require_relative 'shared_dependency_scanner'
 require_relative 'source_nesting'
@@ -58,7 +60,7 @@ module Woods
         units.concat(extract_state_machines_units(source, class_name, file_path))
         units
       rescue StandardError => e
-        Rails.logger.error("Failed to extract state machines from #{file_path}: #{e.message}")
+        SourceInputs::ConsumerErrors.log(self, "Failed to extract state machines from #{file_path}: #{e.message}")
         []
       end
 

data/lib/woods/extractors/test_mapping_extractor.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../source_inputs/consumer_errors'
+
 require_relative 'shared_utility_methods'
 require_relative 'shared_dependency_scanner'
 
@@ -70,7 +72,7 @@ module Woods
 
         unit
       rescue StandardError => e
-        Rails.logger.error("Failed to extract test mapping from #{file_path}: #{e.message}")
+        SourceInputs::ConsumerErrors.log(self, "Failed to extract test mapping from #{file_path}: #{e.message}")
         nil
       end
 

data/lib/woods/extractors/validator_extractor.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../source_inputs/consumer_errors'
+
 require_relative 'shared_utility_methods'
 require_relative 'shared_dependency_scanner'
 
@@ -70,7 +72,7 @@ module Woods
 
         unit
       rescue StandardError => e
-        Rails.logger.error("Failed to extract validator #{file_path}: #{e.message}")
+        SourceInputs::ConsumerErrors.log(self, "Failed to extract validator #{file_path}: #{e.message}")
         nil
       end
 

data/lib/woods/extractors/view_component_extractor.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../source_inputs/consumer_errors'
+
 require_relative 'component_discovery'
 require_relative 'shared_utility_methods'
 require_relative 'shared_dependency_scanner'
@@ -95,7 +97,7 @@ module Woods
 
         unit
       rescue StandardError => e
-        Rails.logger.error("Failed to extract view component #{component.name}: #{e.message}")
+        SourceInputs::ConsumerErrors.log(self, "Failed to extract view component #{component.name}: #{e.message}")
         nil
       end
 

data/lib/woods/extractors/view_template_extractor.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../source_inputs/consumer_errors'
+
 require 'set'
 require_relative 'route_helper_resolver'
 require_relative 'view_engines/base'
@@ -95,7 +97,7 @@ module Woods
 
         unit
       rescue StandardError => e
-        Rails.logger.error("Failed to extract view template #{file_path}: #{e.message}")
+        SourceInputs::ConsumerErrors.log(self, "Failed to extract view template #{file_path}: #{e.message}")
         nil
       end
 

data/lib/woods/gem_mapper.rb

@@ -7,6 +7,7 @@ require 'pathname'
 require 'time'
 
 require_relative 'atomic_file'
+require_relative 'version'
 require_relative 'coordination/pipeline_lock'
 require_relative 'dependency_graph'
 require_relative 'extracted_unit'
@@ -267,6 +268,7 @@ module Woods
       end
       manifest = {
         extracted_at: Time.now.utc.iso8601, rails_version: nil, ruby_version: RUBY_VERSION,
+        woods_version: Woods::VERSION,
         counts: counts, total_units: @units.size, total_chunks: 0, git_sha: nil, git_branch: nil,
         provenance: GemMapper::PROVENANCE.merge(source_checksum: @checksum),
         graph_nodes: @graph.to_h.dig(:stats, :node_count), graph_edges: @graph.to_h.dig(:stats, :edge_count)

data/lib/woods/git_history.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'time'
+require_relative 'git_command'
+
+module Woods
+  # Stream HEAD-reachable touched-path events without pathspec simplification.
+  # Raw NUL records keep filenames separate from commit fields; only requested
+  # paths are retained. Merge diffs compare against the first parent, while
+  # traversal still visits every parent. Requires Git 2.31 or newer.
+  class GitHistory
+    class ReadError < StandardError; end
+
+    FORMAT = '%x00%H%x00%an%x00%cI%x00%s%x00'
+    private_constant :FORMAT
+
+    def initialize(root:, logger:)
+      @root = root
+      @logger = logger
+    end
+
+    # @return [Hash, nil] raw per-path aggregates, or nil on any incomplete read
+    def read(paths, recent_after:)
+      requested = paths.to_h { |path| [repository_prefix + path.b, path] }
+      result = paths.to_h { |path| [path, {}] }
+      stream { |stdout| parse(stdout, requested, result, recent_after) }
+      result
+    rescue StandardError => e
+      @logger.warn('[Woods] Git enrichment omitted: history could not be read completely. ' \
+                   'Git 2.31 or newer is required; check the application repository and git installation. ' \
+                   "(#{e.class})")
+      nil
+    end
+
+    private
+
+    def repository_prefix
+      return @repository_prefix if defined?(@repository_prefix)
+
+      prefix, _error, status = Open3.capture3(*GitCommand.argv(@root, 'rev-parse', '--show-prefix'))
+      raise ReadError, 'cannot resolve application path in repository' unless status.success?
+
+      @repository_prefix = prefix.delete_suffix("\n").b
+    end
+
+    def stream
+      argv = GitCommand.argv(@root, '-c', 'log.showSignature=false', 'log', 'HEAD',
+                             '--since=365 days ago', '--root', '--raw', '-z', '--no-renames',
+                             '--no-relative', '--no-ext-diff', '--encoding=UTF-8',
+                             '--diff-merges=first-parent', "--format=#{FORMAT}")
+      Open3.popen3(*argv) do |stdin, stdout, stderr, wait|
+        stdin.close
+        stdout.binmode
+        # Drain stderr without retaining a potentially unbounded diagnostic.
+        drain = Thread.new { stderr.read(16_384) until stderr.eof? }
+        begin
+          yield stdout
+          raise ReadError, "history command exited #{wait.value.exitstatus}" unless wait.value.success?
+        ensure
+          stdout.close
+          drain.join
+        end
+      end
+    end
+
+    def token(io)
+      value = io.gets("\0")
+      return nil unless value
+      raise ReadError, 'unterminated history record' unless value.end_with?("\0")
+
+      value.delete_suffix("\0")
+    end
+
+    def parse(io, requested, result, recent_after)
+      commit = nil
+      while (field = token(io))
+        next if field.empty?
+
+        if field.match?(/\A[0-9a-f]{40}(?:[0-9a-f]{24})?\z/)
+          commit = read_commit(io, field, recent_after)
+        elsif field.match?(/\A\n?:[0-7]{6} [0-7]{6} [0-9a-f]+ [0-9a-f]+ [A-Z]\z/)
+          record_path(io, requested, result, commit)
+        else
+          raise ReadError, 'unexpected history record'
+        end
+      end
+    end
+
+    def read_commit(io, sha, recent_after)
+      author, date, message = Array.new(3) { token(io) }
+      raise ReadError, 'incomplete commit header' unless author && date && message
+
+      { sha: sha, author: author.force_encoding(Encoding::UTF_8),
+        date: date, message: message.force_encoding(Encoding::UTF_8), recent: Time.iso8601(date) > recent_after }
+    end
+
+    def record_path(io, requested, result, commit)
+      path = token(io)
+      raise ReadError, 'incomplete path record' unless commit && path
+
+      relative = requested[path]
+      record(result[relative], commit) if relative
+    end
+
+    def record(data, commit)
+      data[:last_modified] ||= commit[:date]
+      data[:last_author] ||= commit[:author]
+      data[:commit_count] = data.fetch(:commit_count, 0) + 1
+      data[:recent_count] = data.fetch(:recent_count, 0) + (commit[:recent] ? 1 : 0)
+      commits = (data[:commits] ||= [])
+      commits << commit if commits.size < 5
+      (data[:contributors] ||= Hash.new(0))[commit[:author]] += 1
+    end
+  end
+end

data/lib/woods/graph_analyzer.rb

@@ -71,12 +71,14 @@ module Woods
 
     # @param dependency_graph [DependencyGraph] The graph to analyze
     # @param volatile_ratio [Numeric] see {#volatile_dependencies}
+    # @param volatile_limit_per_target [Integer, nil] maximum edges per typed dependency, before the global limit
     # @param cycle_limit [Integer, nil] see {DEFAULT_CYCLE_LIMIT}
     # @param cycle_max_length [Integer, nil] see {DEFAULT_CYCLE_MAX_LENGTH}
-    def initialize(dependency_graph, volatile_ratio: DEFAULT_VOLATILE_RATIO,
+    def initialize(dependency_graph, volatile_ratio: DEFAULT_VOLATILE_RATIO, volatile_limit_per_target: nil,
                    cycle_limit: DEFAULT_CYCLE_LIMIT, cycle_max_length: DEFAULT_CYCLE_MAX_LENGTH)
       @graph = dependency_graph
       @volatile_ratio = volatile_ratio.to_f
+      @volatile_limit_per_target = volatile_limit_per_target
       @cycle_limit = cycle_limit
       @cycle_max_length = cycle_max_length
       @cycle_limit_reached = false
@@ -296,15 +298,16 @@ module Woods
     # dependencies with fewer than {VOLATILE_MIN_COMMITS} commits or a
     # `new` change frequency are skipped. Ranked by the dependency's
     # PageRank so the most-depended-on volatile unit comes first. `limit`
-    # caps what this method hands back; {#analyze}'s
+    # caps what this method hands back after the optional per-target cap; {#analyze}'s
     # `stats[:volatile_dependency_count]` reports the full qualifying count
     # regardless of `limit`, and `stats[:volatile_dependencies_limit]` reports
-    # the cap, so a reader of the array alone can tell it was truncated.
+    # the global cap. An enabled per-target cap also publishes its setting
+    # and the final reported count; the full qualifying count is unchanged.
     #
     # @param limit [Integer] maximum entries
     # @return [Array<Hash>] `{ from:, from_type:, to:, to_type:, via:, from_commits:, to_commits:, ratio:, pagerank: }`
     def volatile_dependencies(limit: DEFAULT_VOLATILE_LIMIT)
-      all_volatile_dependencies.first(limit)
+      capped_volatile_dependencies.first(limit)
     end
 
     # Edges that cross a Packwerk package boundary the source package never
@@ -397,8 +400,7 @@ module Woods
           cycle_count: computed_cycles.size,
           cycle_limit_reached: cycle_limit_reached?,
           cross_database_edge_count: computed_cross_database.size,
-          volatile_dependency_count: all_volatile_dependencies.size,
-          volatile_dependencies_limit: DEFAULT_VOLATILE_LIMIT,
+          **volatile_dependency_stats(computed_volatile),
           undeclared_package_edge_count: computed_undeclared.size
         }
       }
@@ -722,6 +724,33 @@ module Woods
       @all_volatile_dependencies ||= compute_volatile_dependencies
     end
 
+    # Apply the optional hub cap after ranking, before the overall report
+    # limit. Keep individual relationship edges; two `via` values consume two
+    # slots. Type is part of dependency identity, never just the display name.
+    def capped_volatile_dependencies
+      return all_volatile_dependencies unless @volatile_limit_per_target
+
+      counts = Hash.new(0)
+      all_volatile_dependencies.select do |entry|
+        target = [entry[:to_type], entry[:to]]
+        counts[target] += 1
+        counts[target] <= @volatile_limit_per_target
+      end
+    end
+
+    # Preserve the default artifact exactly; expose extra selection metadata
+    # only when the per-target cap was requested. The full count always means
+    # all ratio-qualified edges, before either cap.
+    def volatile_dependency_stats(reported)
+      stats = { volatile_dependency_count: all_volatile_dependencies.size,
+                volatile_dependencies_limit: DEFAULT_VOLATILE_LIMIT }
+      if @volatile_limit_per_target
+        stats[:volatile_dependencies_limit_per_target] = @volatile_limit_per_target
+        stats[:volatile_dependency_reported_count] = reported.size
+      end
+      stats
+    end
+
     # Short-circuits to `[]`, skipping the PageRank computation entirely,
     # when no node carries an Integer `commit_count` (git enrichment never
     # ran): there is nothing to rank.

data/lib/woods/hooks/context_cli.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'timeout'
+
+module Woods
+  module Hooks
+    # The plugin's independent process-group deadline also includes bundle/Ruby
+    # startup. This inner deadline keeps ordinary direct calls short as well.
+    class ContextCLI
+      MAX_INPUT_BYTES = 1_048_576
+      HELP = 'Usage: woods-hook-context SessionStart|PostToolUse < claude-event.json; ' \
+             'opt in with WOODS_HOOK_CONTEXT_ENABLED=1. Prefer the bounded plugin hook entry point.'
+
+      def self.run(kind, input: $stdin, output: $stdout)
+        return output.puts(HELP) || 0 if kind == '--help'
+
+        return 0 if ENV['WOODS_HOOKS_DISABLED'] == '1' || ENV['WOODS_HOOK_CONTEXT_ENABLED'] != '1'
+        return 0 unless %w[SessionStart PostToolUse].include?(kind)
+
+        Timeout.timeout(0.65) do
+          require 'woods'
+          require 'woods/hooks/context_hint'
+          require 'woods/hooks/context_state'
+          emit(kind, input, output)
+        end
+        0
+      rescue Timeout::Error, JSON::ParserError, ArgumentError, KeyError, TypeError, SystemCallError, IOError
+        # Missing/degraded/slow inputs are optional context, not permission to
+        # run extraction, read application data, or acknowledge queued edits.
+        0
+      end
+
+      def self.emit(kind, input, output)
+        bytes = input.read(MAX_INPUT_BYTES + 1)
+        return if bytes.bytesize > MAX_INPUT_BYTES
+
+        event = JSON.parse(bytes)
+        return unless event.is_a?(Hash) && event['hook_event_name'] == kind
+
+        root = ENV['WOODS_HOOK_CONTEXT_ROOT'] || event.fetch('cwd')
+        directory = File.expand_path(ENV.fetch('WOODS_OUTPUT', 'tmp/woods'), root)
+        result = ContextHint.new(event: event, output_dir: directory, root: root).call
+        return unless result
+
+        ContextState.new(directory).emit(result) do
+          output.write(ContextOutput.new(kind).encode(result.fetch(:context)))
+          output.flush
+        end
+      end
+      private_class_method :emit
+    end
+  end
+end

data/lib/woods/hooks/context_event.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'woods/input_rules'
+
+module Woods
+  module Hooks
+    # Claude context events are deliberately separate from refresh queue records.
+    class ContextEvent
+      MAX_FILE_BYTES = 1_048_576
+      attr_reader :root, :path, :kind, :session
+
+      def initialize(input, root: nil)
+        validate_root!(input)
+
+        @logical_root = File.expand_path(input['cwd'])
+        @root = File.realpath(root || @logical_root)
+        @kind = input['hook_event_name']
+        @session = input['session_id'] if valid_string?(input['session_id'], 256)
+        return if kind == 'SessionStart'
+
+        raise ArgumentError unless kind == 'PostToolUse' && %w[Edit Write MultiEdit].include?(input['tool_name'])
+
+        @path = relative_path(input.fetch('tool_input').fetch('file_path'))
+      end
+
+      def eligible?
+        return true if kind == 'SessionStart'
+
+        require 'woods/extractor' unless defined?(Woods::Extractor::EXTRACTORS)
+        InputRules.new.action(path) != :ignore
+      end
+
+      def fingerprint
+        return 'orientation' if kind == 'SessionStart'
+
+        flags = File::RDONLY | File::NONBLOCK
+        flags |= File::NOFOLLOW if defined?(File::NOFOLLOW)
+        File.open(File.join(root, path), flags) do |file|
+          return nil unless file.stat.file? && file.stat.size <= MAX_FILE_BYTES
+
+          bytes = file.read(MAX_FILE_BYTES + 1)
+          return nil if bytes.bytesize > MAX_FILE_BYTES
+
+          Digest::SHA256.hexdigest(bytes)
+        end
+      rescue Errno::ENOENT
+        'missing'
+      rescue SystemCallError, IOError
+        nil
+      end
+
+      private
+
+      def validate_root!(input)
+        raise ArgumentError unless input.is_a?(Hash) && valid_string?(input['cwd']) && input['cwd'].start_with?('/')
+      end
+
+      def valid_string?(value, limit = 4096)
+        value.is_a?(String) && !value.empty? && value.bytesize <= limit &&
+          value.valid_encoding? && !value.include?("\0")
+      end
+
+      def relative_path(value)
+        raise ArgumentError unless valid_string?(value)
+
+        prefix = [@logical_root, root].find { |base| value.start_with?("#{base}/") }
+        relative = prefix ? value.delete_prefix("#{prefix}/") : value
+        validate_parts!(relative)
+        validate_containment!(relative)
+        relative
+      end
+
+      def validate_parts!(relative)
+        parts = relative.split('/', -1)
+        raise ArgumentError if relative.start_with?('/') || parts.size > 64
+        raise ArgumentError if parts.any? { |part| ['', '.', '..'].include?(part) }
+      end
+
+      def validate_containment!(relative)
+        candidate = File.join(root, relative)
+        candidate = File.dirname(candidate) until File.exist?(candidate) || File.symlink?(candidate)
+        resolved = File.realpath(candidate)
+        raise ArgumentError unless resolved == root || resolved.start_with?("#{root}/")
+      end
+    end
+  end
+end

data/lib/woods/hooks/context_hint.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'woods/mcp/index_reader'
+require_relative 'context_event'
+require_relative 'context_output'
+require_relative 'context_impact'
+
+module Woods
+  module Hooks
+    # A bounded snapshot hint. The outer hook process owns the end-to-end deadline.
+    class ContextHint
+      MAX_ARTIFACT_BYTES = 16 * 1024 * 1024
+
+      def initialize(event:, output_dir:, root: nil)
+        @event = ContextEvent.new(event, root: root)
+        @output = File.expand_path(output_dir, @event.root)
+        @renderer = ContextOutput.new(@event.kind)
+      rescue ArgumentError, KeyError, TypeError, SystemCallError
+        @event = nil
+      end
+
+      def call
+        return nil unless @event&.eligible?
+
+        @reader = MCP::IndexReader.new(@output)
+        @reader.with_pinned_generation do
+          @generation = @reader.generation_identity
+          raise ArgumentError if @reader.payload_dir.to_s == @output
+
+          check_artifacts!
+          freshness = source_freshness
+          text = if @event.kind == 'SessionStart'
+                   orientation(freshness)
+                 else
+                   ContextImpact.new(@reader, @renderer).call(@event.path, @generation.first, freshness)
+                 end
+          result(text)
+        end
+      rescue ArgumentError, KeyError, TypeError, NoMethodError, JSON::ParserError, SystemCallError, IOError
+        { context: ContextOutput::UNAVAILABLE, identity: nil, session: nil }
+      end
+
+      private
+
+      def check_artifacts!
+        %w[manifest.json dependency_graph.json source_inputs.json].each do |name|
+          file = @reader.payload_dir.join(name)
+          next if name == 'source_inputs.json' && !file.exist?
+
+          raise ArgumentError unless file.file? && file.size <= MAX_ARTIFACT_BYTES
+        end
+      end
+
+      def source_freshness
+        SourceInputs::Status.new(output_dir: @output, root: @event.root, payload_dir: @reader.payload_dir,
+                                 generation: @reader.loaded_generation).call.fetch('state')
+      end
+
+      def orientation(freshness)
+        @renderer.context("Woods index generation #{@generation.first}; source freshness: #{freshness}. " \
+                          'Use woods_status, search and typed lookup; dependents explain:true suggests checks.')
+      end
+
+      def result(text)
+        fingerprint = @event.fingerprint
+        identity = if fingerprint && @event.session
+                     Digest::SHA256.hexdigest(JSON.generate([@event.root, @event.path, @generation, fingerprint, text]))
+                   end
+        { context: text, identity: identity, session: @event.session, root: @event.root }
+      end
+    end
+  end
+end