phronomy 0.15.0 → 0.16.0

data/lib/phronomy/content_store/base.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Phronomy
+  module ContentStore
+    class IntegrityError < Phronomy::Error; end
+
+    class Base
+      def put(_bytes, canonicalization_version:) = raise(NotImplementedError)
+      def fetch(_content_id) = raise(NotImplementedError)
+      def exist?(_content_id) = raise(NotImplementedError)
+
+      def put_text(text)
+        value = String(text).encode(Encoding::UTF_8)
+        raise ArgumentError, "invalid UTF-8 text" unless value.valid_encoding?
+
+        put(value, canonicalization_version: 1)
+      end
+
+      def put_json(value)
+        put(
+          Phronomy::CanonicalJSON.dump(value),
+          canonicalization_version: Phronomy::CanonicalJSON::VERSION
+        )
+      end
+
+      def fetch_text(content_id)
+        value = fetch(content_id).force_encoding(Encoding::UTF_8)
+        unless value.valid_encoding?
+          raise IntegrityError, "content is not UTF-8: #{content_id}"
+        end
+        value
+      end
+
+      def fetch_json(content_id)
+        Phronomy::CanonicalJSON.load(fetch(content_id))
+      end
+
+      def fetch_many(content_ids)
+        Array(content_ids).uniq.to_h { |content_id| [content_id, fetch(content_id)] }
+      end
+
+      private
+
+      def content_id_for(bytes)
+        "sha256:#{Digest::SHA256.hexdigest(bytes)}"
+      end
+    end
+  end
+end

data/lib/phronomy/context_budget_exceeded_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Phronomy
+  # Raised when mandatory context content (system instructions, tool definitions,
+  # current input) exhausts the model's context window, leaving no room for
+  # prior conversation history.
+  class ContextBudgetExceededError < Error; end
+end

data/lib/phronomy/engine/event_loop.rb

@@ -319,6 +319,9 @@ module Phronomy
         @fsms[session.id] = session
         @waiting[session.id] = waiter if waiter
         session.start
+      when :agent_terminal_ready
+        cmd = event.payload.fetch(:command)
+        cmd.coordinator.deliver_on_event_loop(cmd)
       end
     end
 

data/lib/phronomy/execution_rehydration_required_error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Phronomy
+  class ExecutionRehydrationRequiredError < Phronomy::Error; end
+end

data/lib/phronomy/invalid_context_budget_configuration_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Phronomy
+  # Raised when output token reserve cannot be determined at budget construction
+  # time (e.g. no explicit max_output_tokens set and registry value equals the
+  # context window).
+  class InvalidContextBudgetConfigurationError < Error; end
+end

data/lib/phronomy/llm_context_window/assembler.rb

@@ -14,9 +14,10 @@ module Phronomy
     #   4. Conversation — historical messages added via #add_messages
     #
     # Token budgeting:
-    #   When a budget is given, conversation messages are trimmed from oldest to
-    #   newest until they fit. Capability token cost is estimated and deducted
-    #   from the budget before conversation trimming so the reserve is accurate.
+    #   When a budget is given, Assembler validates that the supplied conversation
+    #   messages fit after instruction, knowledge, and capability costs are
+    #   accounted for. It does not prune messages; Manifest-first Context Policy
+    #   is responsible for context selection.
     #   Knowledge chunks are always included in full (they are assumed to be
     #   pre-screened by the caller). When no budget is given all messages are
     #   passed through unchanged.
@@ -44,7 +45,7 @@ module Phronomy
       end
 
       # @param budget [Phronomy::LlmContextWindow::TokenBudget, nil]
-      #   when nil no token trimming is performed
+      #   when nil no budget validation is performed
       # @api private
       # mutant:disable - @instruction = nil deletion is a genuine equivalent (uninitialized Ruby instance variables return nil)
       def initialize(budget: nil)
@@ -57,7 +58,7 @@ module Phronomy
 
       # Register tool classes (Region 2).
       # Estimates their token cost and deducts it from the budget so that
-      # conversation trimming accounts for tool definition overhead.
+      # budget estimation accounts for tool definition overhead.
       #
       # @param tool_classes [Array<Class, Object>] tool classes or instances
       # @return [self]
@@ -131,8 +132,7 @@ module Phronomy
       # Raises {Phronomy::ContextLengthError} when a budget is set and the
       # conversation messages do not fit within the remaining token allowance.
       # No automatic trimming is performed — callers must pre-process messages
-      # (e.g. via Agent::Base#trim_messages or #compact_messages) before
-      # passing them to the Assembler.
+      # before passing them to the Assembler.
       #
       # mutant:disable - multiple genuine equivalent mutations: map{}.join("\n\n") → map{} is genuine; `unless knowledge_text.empty?` vs ternary is genuine; `{ system: unless system_text.empty? }` vs ternary is genuine; `messages:` shorthand vs `messages: messages` is genuine
       def build
@@ -149,7 +149,7 @@ module Phronomy
             raise Phronomy::ContextLengthError,
               "Context exceeds token budget: messages require #{msg_tokens} tokens but " \
               "only #{remaining} available (context_window=#{@budget.context_window}, " \
-              "used_by_system=#{used}). Override build_context to trim or compact messages."
+              "used_by_system=#{used}). Use the Context Policy path to manage message budget."
           end
         end
 

data/lib/phronomy/multi_agent/orchestrator.rb

@@ -42,6 +42,7 @@ module Phronomy
     # @example Fan-out (same agent, multiple inputs)
     #   results = fan_out(agent: TranslationAgent, inputs: ["Hello", "World"])
     class Orchestrator < Agent::Base
+      agent_definition id: "orchestrator", version: 1
       # Declares a named subagent and registers it as a tool accessible to the
       # LLM during an +invoke+ call.
       #

data/lib/phronomy/multi_agent/parallel_tool_chat.rb

@@ -31,16 +31,18 @@ module Phronomy
         return super if tool_calls.size <= 1
 
         if @on[:tool_call_batch]
-          tool_calls.each { @on[:new_message]&.call }
+          tool_calls.each { run_callbacks(:before_message, :new_message) }
           @on[:tool_call_batch].call(tool_calls)
           return
         end
 
         # Direct ParallelToolChat fallback. Agent execution never reaches this
         # branch because AgentInvocation installs the batch interceptor first.
+        # RubyLLM >= 1.15 additive callbacks are dispatched together with their
+        # legacy equivalents, matching RubyLLM::Chat semantics.
         tool_calls.each do |tool_call|
-          @on[:new_message]&.call
-          @on[:tool_call]&.call(tool_call)
+          run_callbacks(:before_message, :new_message)
+          run_callbacks(:before_tool_call, :tool_call, tool_call)
         end
 
         cancellation_token = @cancellation_token
@@ -78,7 +80,7 @@ module Phronomy
         halt_result = nil
         tool_results.each do |item|
           result = item[:result]
-          @on[:tool_result]&.call(result)
+          run_callbacks(:after_tool_result, :tool_result, result)
           tool_payload = result.is_a?(RubyLLM::Tool::Halt) ? result.content : result
           content = content_like?(tool_payload) ? tool_payload : tool_payload.to_s
           message = add_message(
@@ -86,7 +88,7 @@ module Phronomy
             content: content,
             tool_call_id: item[:tool_call].id
           )
-          @on[:end_message]&.call(message)
+          run_callbacks(:after_message, :end_message, message)
           halt_result = result if result.is_a?(RubyLLM::Tool::Halt)
         end
 

data/lib/phronomy/multi_agent/team_coordinator.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "securerandom"
+
 module Phronomy
   module MultiAgent
     # Implements the "Agent teams" coordination pattern (Anthropic blog, Pattern 3).
@@ -212,8 +214,9 @@ module Phronomy
           worker = scheduler ? scheduler.call(available) : default_scheduler(available)
 
           begin
-            result = worker.agent.invoke(task[:description], messages: worker.messages)
-            worker.messages = result[:messages]
+            # Worker agent retains conversation history in its Journal.
+            result = worker.agent.invoke(task[:description])
+            worker.messages = Array(result[:messages])
             worker.status = :available
             entry = {task: task, result: result[:output], worker: worker.index, error: nil}
             assignments << entry
@@ -253,6 +256,7 @@ module Phronomy
         finalize_tool = build_finalize_tool(task_queue)
 
         coordinator_class = Class.new(Phronomy::Agent::Base) do
+          agent_definition id: "team-coordinator-#{SecureRandom.hex(4)}", version: 1
           model coordinator_model_val
           provider coordinator_provider_val if coordinator_provider_val
           instructions coordinator_instructions_val

data/lib/phronomy/persistence/in_memory.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require "monitor"
+require "digest"
+
+module Phronomy
+  class Persistence
+    class InMemory < Persistence
+      class Contents < Phronomy::ContentStore::Base
+        def initialize(owner)
+          @owner = owner
+        end
+
+        def put(bytes, canonicalization_version:)
+          value = String(bytes).b.freeze
+          id = content_id_for(value)
+          @owner.synchronize do
+            current = @owner.state[:contents][id]
+            if current && current[:bytes] != value
+              raise Phronomy::ContentStore::IntegrityError, "digest collision for #{id}"
+            end
+            @owner.state[:contents][id] ||= {
+              bytes: value,
+              canonicalization_version: Integer(canonicalization_version)
+            }
+          end
+          id
+        end
+
+        def fetch(content_id)
+          @owner.synchronize do
+            record = @owner.state[:contents].fetch(content_id.to_s) do
+              raise NotFoundError, "content not found: #{content_id}"
+            end
+            bytes = record[:bytes]
+            unless content_id_for(bytes) == content_id.to_s
+              raise Phronomy::ContentStore::IntegrityError, "content digest mismatch: #{content_id}"
+            end
+            bytes.dup
+          end
+        end
+
+        def exist?(content_id)
+          @owner.synchronize { @owner.state[:contents].key?(content_id.to_s) }
+        end
+      end
+
+      class Agents
+        def initialize(owner) = @owner = owner
+
+        def create(root)
+          @owner.synchronize do
+            key = root.agent_id.to_s
+            raise ConflictError, "agent_id must not be empty" if key.empty?
+            raise ConflictError, "agent already exists: #{key}" if @owner.state[:agents].key?(key)
+            @owner.state[:agents][key] = root
+          end
+          root
+        end
+
+        def load(agent_id)
+          @owner.synchronize do
+            @owner.state[:agents].fetch(agent_id.to_s) { raise NotFoundError, "agent not found: #{agent_id}" }
+          end
+        end
+
+        def save(agent_id, expected_revision:, root:)
+          @owner.synchronize do
+            current = load(agent_id)
+            unless current.agent_revision == expected_revision
+              raise ConflictError,
+                "agent revision conflict: expected #{expected_revision}, actual #{current.agent_revision}"
+            end
+            unless root.agent_id.to_s == agent_id.to_s
+              raise ConflictError, "Agent root identity mismatch: #{root.agent_id} != #{agent_id}"
+            end
+            unless root.agent_revision == expected_revision + 1
+              raise ConflictError,
+                "agent save must advance revision exactly once: " \
+                "expected #{expected_revision + 1}, got #{root.agent_revision}"
+            end
+            @owner.state[:agents][agent_id.to_s] = root
+          end
+          root
+        end
+
+        def delete(agent_id)
+          @owner.synchronize { @owner.state[:agents].delete(agent_id.to_s) }
+        end
+      end
+
+      class Journals
+        def initialize(owner) = @owner = owner
+
+        def append(agent_id, expected_position:, records:)
+          @owner.synchronize do
+            target = (@owner.state[:journals][agent_id.to_s] ||= [])
+            unless target.length == expected_position
+              raise ConflictError,
+                "journal position conflict: expected #{expected_position}, actual #{target.length}"
+            end
+            existing_ids = target.to_h { |record| [record.record_id, true] }
+            incoming_ids = {}
+            appended = Array(records).each_with_index.map do |record, index|
+              unless record.agent_id.to_s == agent_id.to_s
+                raise ConflictError,
+                  "Journal record Agent mismatch: #{record.agent_id} != #{agent_id}"
+              end
+              if existing_ids[record.record_id] || incoming_ids[record.record_id]
+                raise ConflictError, "duplicate Journal record_id: #{record.record_id}"
+              end
+              incoming_ids[record.record_id] = true
+              record.with_sequence(expected_position + index + 1)
+            end
+            target.concat(appended)
+            appended.freeze
+          end
+        end
+
+        def read(agent_id, after: nil, limit: nil)
+          @owner.synchronize do
+            result = Array(@owner.state[:journals][agent_id.to_s])
+            result = result.drop(Integer(after)) if after
+            result = result.first(limit) if limit
+            result.dup.freeze
+          end
+        end
+
+        def head(agent_id)
+          @owner.synchronize { Array(@owner.state[:journals][agent_id.to_s]).length }
+        end
+
+        def delete(agent_id)
+          @owner.synchronize { @owner.state[:journals].delete(agent_id.to_s) }
+        end
+      end
+
+      class Executions
+        def initialize(owner) = @owner = owner
+
+        def create_active(execution)
+          @owner.synchronize do
+            if @owner.state[:executions].key?(execution.execution_id.to_s)
+              raise ConflictError, "execution already exists: #{execution.execution_id}"
+            end
+            active = @owner.state[:executions].values.find do |candidate|
+              candidate.agent_id == execution.agent_id && candidate.active?
+            end
+            raise Phronomy::AgentBusyError, "agent is busy: #{execution.agent_id}" if active
+            @owner.state[:executions][execution.execution_id] = execution
+          end
+          execution
+        end
+
+        def load(execution_id)
+          @owner.synchronize do
+            @owner.state[:executions].fetch(execution_id.to_s) do
+              raise NotFoundError, "execution not found: #{execution_id}"
+            end
+          end
+        end
+
+        def save(execution_id, expected_revision:, execution:)
+          @owner.synchronize do
+            current = load(execution_id)
+            unless current.execution_revision == expected_revision
+              raise ConflictError,
+                "execution revision conflict: expected #{expected_revision}, actual #{current.execution_revision}"
+            end
+            unless execution.execution_id.to_s == execution_id.to_s
+              raise ConflictError,
+                "Execution identity mismatch: #{execution.execution_id} != #{execution_id}"
+            end
+            unless execution.execution_revision == expected_revision + 1
+              raise ConflictError,
+                "execution save must advance revision exactly once: " \
+                "expected #{expected_revision + 1}, got #{execution.execution_revision}"
+            end
+            @owner.state[:executions][execution_id.to_s] = execution
+          end
+          execution
+        end
+
+        def list_active(agent_id)
+          @owner.synchronize do
+            @owner.state[:executions].values.select do |execution|
+              execution.agent_id == agent_id.to_s && execution.active?
+            end.freeze
+          end
+        end
+
+        def delete(execution_id)
+          @owner.synchronize { @owner.state[:executions].delete(execution_id.to_s) }
+        end
+
+        def delete_for_agent(agent_id)
+          @owner.synchronize do
+            @owner.state[:executions].delete_if { |_id, execution| execution.agent_id == agent_id.to_s }
+          end
+        end
+
+        # Raises AgentBusyError if there is an active execution for agent_id.
+        # Must be called from within a transaction (monitor already held).
+        def assert_idle!(agent_id)
+          active = @owner.state[:executions].values.find do |candidate|
+            candidate.agent_id == agent_id.to_s && candidate.active?
+          end
+          raise Phronomy::AgentBusyError, "agent has an active or suspended execution: #{agent_id}" if active
+        end
+      end
+
+      attr_reader :state
+
+      def initialize
+        @monitor = Monitor.new
+        @state = {contents: {}, agents: {}, journals: {}, executions: {}}
+        @contents = Contents.new(self)
+        @agents = Agents.new(self)
+        @journals = Journals.new(self)
+        @executions = Executions.new(self)
+        @activations = Phronomy::Agent::ActivationRegistry.new
+        super(contents: @contents, agents: @agents, journals: @journals,
+              executions: @executions, activations: @activations)
+      end
+
+      def capabilities
+        {atomic_all: true, atomic_admission: true, optimistic_revision: true}.freeze
+      end
+
+      def transaction
+        synchronize do
+          snapshot = Marshal.load(Marshal.dump(@state))
+          begin
+            yield self
+          rescue
+            @state = snapshot
+            raise
+          end
+        end
+      end
+
+      def synchronize(&block)
+        @monitor.synchronize(&block)
+      end
+    end
+  end
+end

data/lib/phronomy/persistence.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Phronomy
+  class Persistence
+    class ConflictError < Phronomy::Error; end
+    class NotFoundError < Phronomy::Error; end
+    class UnsupportedBackendError < Phronomy::Error; end
+
+    attr_reader :contents, :agents, :journals, :executions, :activations
+
+    def initialize(contents:, agents:, journals:, executions:, activations:)
+      @contents = contents
+      @agents = agents
+      @journals = journals
+      @executions = executions
+      @activations = activations
+      validate_capabilities!
+    end
+
+    def capabilities
+      {atomic_all: false, atomic_admission: false}.freeze
+    end
+
+    def transaction
+      raise UnsupportedBackendError, "#{self.class} does not provide atomic_all"
+    end
+
+    private
+
+    def validate_capabilities!
+      required = {atomic_all: true, atomic_admission: true}
+      missing = required.reject { |key, value| capabilities[key] == value }
+      return if missing.empty?
+
+      raise UnsupportedBackendError,
+        "Persistence backend lacks required capabilities: #{missing.keys.join(", ")}"
+    end
+  end
+end

data/lib/phronomy/tools/agent.rb

@@ -3,69 +3,47 @@
 module Phronomy
   module Tools
     # Wraps a Phronomy::Agent::Base subclass as a callable tool so that a parent
-    # agent can delegate sub-tasks to a fully-capable sub-agent.
-    #
-    # Use Agent.from_agent to generate a concrete tool class.  The generated
-    # class is anonymous; assign it to a constant when you need a stable name.
-    #
-    # @example Wrap an existing agent
-    #   SummarizerTool = Phronomy::Tools::Agent.from_agent(
-    #     SummarizerAgent,
-    #     tool_name:   "summarize",
-    #     description: "Summarizes a long text and returns a brief summary"
-    #   )
-    #
-    #   class OrchestratorAgent < Phronomy::Agent::Base
-    #     model "openai/gpt-4o-mini"
-    #     instructions "You are an orchestrator that delegates to specialist agents."
-    #     tools SummarizerTool
-    #   end
+    # agent can delegate a one-shot sub-task through the same stateful pipeline.
     class Agent < Phronomy::Agent::Context::Capability::Base
       description "Wraps an agent as a tool"
       param :input, type: :string, desc: "The input to forward to the wrapped agent"
 
       class << self
-        # Generates a Phronomy::Tools::Agent subclass that delegates #execute to
-        # an instance of +agent_class+.
-        #
-        # @param agent_class  [Class] a Phronomy::Agent::Base subclass
-        # @param tool_name    [String, nil] function name exposed to the LLM;
-        #   defaults to a snake_case derivation of the agent class name
-        # @param description  [String, nil] description exposed to the LLM;
-        #   defaults to "Delegates to <AgentClassName>"
-        # @return [Class] an anonymous Phronomy::Tools::Agent subclass
-        # @api public
         def from_agent(agent_class, tool_name: nil, description: nil)
           raise ArgumentError, "agent_class must be a Class" unless agent_class.is_a?(Class)
+          unless agent_class <= Phronomy::Agent::Base
+            raise ArgumentError,
+              "agent_class must inherit from Phronomy::Agent::Base"
+          end
 
-          klass = Class.new(self)
+          # Fail at Tool definition time rather than on the first Tool call.
+          agent_class.agent_definition
 
+          klass = Class.new(self)
           effective_name = tool_name || derive_name(agent_class)
           effective_desc = description || "Delegates to #{agent_class.name || "an agent"}"
 
           klass.tool_name(effective_name)
           klass.description(effective_desc)
-
           klass.define_method(:execute) do |input:|
-            result = agent_class.new.invoke(input)
+            result = Phronomy::Agent.run_once(
+              definition: agent_class,
+              input: input
+            )
             result[:output].to_s
           end
-
           klass
         end
 
         private
 
-        # Derives a snake_case tool name from the agent class name.
-        # e.g. "My::SummarizerAgent" → "summarizer"
-        #      "TranslatorAgent"     → "translator"
         def derive_name(agent_class)
           return "agent_tool" unless agent_class.name
 
           agent_class.name
             .split("::").last
-            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .gsub(/([A-Z]+)([A-Z][a-z])/, '\\1_\\2')
+            .gsub(/([a-z\\d])([A-Z])/, '\\1_\\2')
             .downcase
             .sub(/_agent$/, "")
             .sub(/_tool$/, "")

data/lib/phronomy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Phronomy
-  VERSION = "0.15.0"
+  VERSION = "0.16.0"
 end

data/lib/phronomy.rb

@@ -20,6 +20,17 @@ loader.inflector.inflect("llm_adapter" => "LLMAdapter")
 loader.inflector.inflect("llm_operation_result" => "LLMOperationResult")
 # LLMAdapter::RubyLLM: "ruby_llm" maps to "RubyLLM" (not "RubyLlm").
 loader.inflector.inflect("ruby_llm" => "RubyLLM")
+# CanonicalJSON: preserve uppercase JSON acronym.
+loader.inflector.inflect("canonical_json" => "CanonicalJSON")
+# RubyLLMMaterializer: preserve the double-uppercase LLM acronym.
+loader.inflector.inflect("ruby_llm_materializer" => "RubyLLMMaterializer")
+# LLMCallRecord: preserve uppercase LLM acronym.
+loader.inflector.inflect("llm_call_record" => "LLMCallRecord")
+# LLMInputManifest: preserve uppercase LLM acronym.
+loader.inflector.inflect("llm_input_manifest" => "LLMInputManifest")
+# LLMInputBuildContext / LLMInputPatch: preserve uppercase LLM acronym.
+loader.inflector.inflect("llm_input_build_context" => "LLMInputBuildContext")
+loader.inflector.inflect("llm_input_patch" => "LLMInputPatch")
 # Collapse engine/ so that its contents autoload directly under Phronomy::
 # (no Engine:: prefix).  e.g. engine/event_loop.rb => Phronomy::EventLoop.
 # This allows the execution engine to be organised in its own subdirectory

data/scripts/add_to_h_to_token_doubles.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Adds to_h to all Tokens-like doubles so ExecutionCoordinator can serialize usage.
+
+files = Dir.glob("spec/**/*.rb").sort
+
+total = 0
+files.each do |f|
+  content = File.read(f)
+  modified = content.gsub(
+    /double\(("[^"]+"),\s*(input: \d+, output: \d+, cached: \d+, cache_creation: \d+)\)/
+  ) do
+    name = $1
+    attrs = $2
+    next $& if $&.include?("to_h")
+
+    h_entries = attrs.split(",").map(&:strip).map do |pair|
+      k, v = pair.split(":").map(&:strip)
+      "\"#{k}\" => #{v}"
+    end.join(", ")
+
+    total += 1
+    "double(#{name}, #{attrs}, to_h: {#{h_entries}})"
+  end
+
+  if modified != content
+    File.write(f, modified)
+    puts "  patched: #{f}"
+  end
+end
+
+puts "\nAdded to_h to #{total} Tokens doubles."

data/scripts/add_to_h_unnamed_doubles.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Adds to_h to unnamed (no-string-name) Tokens doubles like double(input: 5, ...)
+
+files = Dir.glob("spec/**/*.rb").sort
+
+total = 0
+files.each do |f|
+  content = File.read(f)
+  modified = content.gsub(
+    /double\((input: (\d+), output: (\d+), cached: (\d+), cache_creation: (\d+))\)/
+  ) do
+    attrs, a, b, c, d = $1, $2, $3, $4, $5
+    next $& if $&.include?("to_h")
+
+    total += 1
+    "double(#{attrs}, to_h: {\"input\" => #{a}, \"output\" => #{b}, \"cached\" => #{c}, \"cache_creation\" => #{d}})"
+  end
+
+  if modified != content
+    File.write(f, modified)
+    puts "  patched: #{f}"
+  end
+end
+
+puts "\nAdded to_h to #{total} unnamed Tokens doubles."