brute 5.0.5 → 5.1.0

data/lib/brute/eval.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "brute"
+
+require_relative "eval/case"
+require_relative "eval/suite"
+require_relative "eval/transcript"
+require_relative "eval/world"
+
+module Brute
+  # Evaluating an agent, rather than testing a middleware.
+  #
+  # A spec asks whether one layer does what it says. An eval asks whether the
+  # whole assembled agent -- its system prompt, its tools, the model behind
+  # it -- behaves. That answer is not a boolean about code: it is a real turn,
+  # against a real model, graded on what the turn DID.
+  #
+  #   CASES = [
+  #     Brute::Eval::Case.new(
+  #       "searches for what it cannot know",
+  #       said:     "what did the Bank of England do yesterday?",
+  #       stubs:    { "search" => RATE_DECISION },
+  #       calls:    { "search" => { "query" => /bank|rate/i } },
+  #       mentions: %w[4.25],
+  #     ),
+  #     Brute::Eval::Case.new(
+  #       "does not search for what it already knows",
+  #       said:   "how many minutes are there in an hour?",
+  #       never:  %w[search],
+  #       budget: Brute::Eval::Budget.new(iterations: 2, tool_calls: 0),
+  #     ),
+  #   ]
+  #
+  #   exit(Brute::Eval::Suite.new(agent: "agent.ru", cases: CASES).run)
+  #
+  # Everything the harness sees comes off the agent's own hooks -- the same
+  # registry any other subscriber uses -- so the agent under evaluation is the
+  # agent that ships: no eval-only middleware, no branch in agent.ru. The
+  # model and the tool schemas are real; the tools themselves answer from the
+  # case's stubs, installed on :before_tool, which answers a call without
+  # executing it.
+  #
+  # Where a case wakes up is the World's business, and a deployment that
+  # delivers what was said through an inbox, a queue or a room subclasses it.
+  module Eval
+  end
+end

data/lib/brute/hooks.rb

@@ -42,6 +42,15 @@ module Brute
   #                             completion middleware then emits one of
   #                             :faraday_error, :open_router_server_error or
   #                             :standard_error with the exception as an extra
+  #   :compact_duration       → env, started, finished, the compactor: one
+  #                             strategy's attempt is this event's block, so
+  #                             the strategy that spends a model call is
+  #                             visible, and one that declined is still timed
+  #   :compacted              → env, {strategy:, before:, after:} — a
+  #                             compaction strategy rewrote env[:messages];
+  #                             what it replaced is already gone, so an
+  #                             application that keeps a transcript preserves
+  #                             it here
   #   :before_tool            → env, call env {name:, arguments:, result:,
   #                             denied:, events:, metadata:, turn_env:} —
   #                             mutate :arguments to rewrite the call, or set
@@ -75,6 +84,8 @@ module Brute
     FARADAY_ERROR_EVENT = :faraday_error
     OPEN_ROUTER_SERVER_ERROR_EVENT = :open_router_server_error
     STANDARD_ERROR_EVENT = :standard_error
+    COMPACT_DURATION_EVENT = :compact_duration
+    COMPACTED_EVENT = :compacted
     BEFORE_TOOL_EVENT = :before_tool
     APPROVE_TOOL_EVENT = :approve_tool
     TOOL_DURATION_EVENT = :tool_duration

data/lib/brute/middleware/000_base.rb

@@ -55,7 +55,7 @@ describe "brute/middleware/000_base" do
 
     # Every middleware in the chain descends from it.
     Brute::Middleware::SystemPrompt.ancestors.should.include Brute::Middleware::Base
-    Brute::Middleware::ToolPipeline.ancestors.should.include Brute::Middleware::Base
+    Brute::Middleware::DefaultToolPipeline.ancestors.should.include Brute::Middleware::Base
     Brute::Middleware::Loop::ToolResult.ancestors.should.include Brute::Middleware::Base
   end
 end

data/lib/brute/middleware/008_checkpoint.rb

@@ -16,7 +16,7 @@ module Brute
     #   use Brute::Middleware::Loop::ToolResult
     #   use Brute::Middleware::Checkpoint, path: "tmp/checkpoints.jsonl"
     #   use Brute::Middleware::MaxIterations
-    #   use Brute::Middleware::ToolPipeline, tools: Brute::Tools::ALL
+    #   use Brute::Middleware::DefaultToolPipeline, tools: Brute::Tools::ALL
     #
     # The store is just a JSONL log of snapshots — one line per checkpoint,
     # each carrying the full message log plus its own id and the id of the

data/lib/brute/middleware/040_compaction_check.rb

@@ -2,150 +2,35 @@
 
 require "bundler/setup"
 require "brute"
+require "gem_kit"
 
 module Brute
   module Middleware
-    # Checks context size after each LLM call and triggers compaction
-    # when thresholds are exceeded.
+    # The old compaction trigger, kept working while it is deprecated.
+    # DefaultCompactionPipeline is the layer that does the job.
     #
-    # It should add a compaction event to the logs with the context token
-    # total listed... this way a model that supports extra context can
-    # include the compaction as well as the previous messages...
+    # It passes the turn through and compacts nothing, which is what it always
+    # did -- and it is deliberately not a subclass of its replacement, because
+    # inheriting would make a layer that did nothing suddenly start giving up
+    # context. A deprecation warns about a name; it does not change what the
+    # code under that name does.
     #
-    # Or an LLM that doesn't support it can just use the messages
-    # that come after the compaction
+    # Whatever it was configured with is accepted and ignored, so existing
+    # `use` lines keep parsing until they are moved over:
+    #
+    #   use Brute::Middleware::DefaultCompactionPipeline,
+    #     window:     200_000,
+    #     summariser: Brute::Completion::OpenRouter.new(config: { access_token: key })
     #
     class CompactionCheck < Brute::Middleware::Base
-      def initialize(app, compactor: nil, system_prompt:, **compactor_opts)
-        @app = app
-        @compactor = compactor
-        @compactor_opts = compactor_opts
-        @system_prompt = system_prompt
-      end
-
-      def call(env)
-        #@compactor ||= Compactor.new(env[:provider], **@compactor_opts)
+      extend GemKit::Deprecate
+      superseded_by "Brute::Middleware::DefaultCompactionPipeline", "6.0"
 
-        #messages = env[:messages]
-        #usage = env[:metadata].dig(:tokens, :last_call)
-
-        #if @compactor.should_compact?(messages, usage: usage)
-        #  result = @compactor.compact(messages)
-        #  if result
-        #    summary_text, _recent = result
-        #    env[:metadata][:compaction] = {
-        #      messages_before: messages.size,
-        #      timestamp: Time.now.iso8601,
-        #    }
-        #    # Replace the message history with the summary
-        #    env[:messages] = [
-        #      Brute::Message.new(role: :system, content: @system_prompt),
-        #      Brute::Message.new(role: :user, content: "[Previous conversation summary]\n\n#{summary_text}"),
-        #    ]
-        #  end
-        #end
-
-        @app.call(env)
+      def initialize(app, **_options)
+        @app = app
       end
 
-      # Context compaction service. When the conversation grows past configurable
-      # thresholds, older messages are summarized into a condensed form and the
-      # original messages are dropped, keeping the context window manageable.
-      class Compactor
-        DEFAULTS = {
-          token_threshold: 100_000,   # Compact when estimated tokens exceed this
-          message_threshold: 200,     # Compact when message count exceeds this
-          retention_window: 6,        # Minimum recent messages to always keep
-          summary_model: nil,         # Model for summarization (uses agent's model if nil)
-        }.freeze
-
-        attr_reader :config
-
-        def initialize(provider, **opts)
-          @provider = provider
-          @config = DEFAULTS.merge(opts)
-        end
-
-        # Check whether compaction should run based on current context state.
-        def should_compact?(messages, usage: nil)
-          return true if messages.size > @config[:message_threshold]
-          return true if usage && (usage[:total] || 0) > @config[:token_threshold]
-          false
-        end
-
-        # Compact the message history by summarizing older messages.
-        #
-        # Returns [summary_message, kept_messages] — the caller rebuilds
-        # the context from these.
-        def compact(messages)
-          total = messages.size
-          keep_count = [@config[:retention_window], total].min
-          return nil if total <= keep_count
-
-          old_messages = messages[0...(total - keep_count)]
-          recent_messages = messages[(total - keep_count)..]
-
-          summary_text = summarize(old_messages)
-
-          [summary_text, recent_messages]
-        end
-
-        private
-
-        def summarize(messages)
-          # Build a condensed representation of the conversation for the summarizer
-          conversation_text = messages.map { |m|
-            role = if m.respond_to?(:role)
-              m.role.to_s
-            else
-              "unknown"
-            end
-            content = if m.respond_to?(:content)
-              m.content.to_s[0..1000]
-            else
-              m.to_s[0..1000]
-            end
-
-            # Include tool call info for assistant messages
-            tool_info = ""
-            if m.respond_to?(:functions) && m.functions&.any?
-              calls = m.functions.map { |f| "#{f.name}(#{f.arguments.to_s[0..200]})" }
-              tool_info = " [tools: #{calls.join(", ")}]"
-            end
-
-            "#{role}:#{tool_info} #{content}"
-          }.join("\n---\n")
-
-          prompt = <<~PROMPT
-            Summarize this conversation history for context continuity. The summary will replace
-            these messages in the context window, so include everything the agent needs to continue
-            working effectively.
-
-            Structure your summary as:
-            ## Goal
-            What the user asked for.
-
-            ## Progress
-            - Files read, created, or modified (list paths)
-            - Commands executed and their outcomes
-            - Key decisions made
-
-            ## Current State
-            Where things stand right now — what's done and what remains.
-
-            ## Next Steps
-            What should happen next based on the conversation.
-
-            ---
-            CONVERSATION:
-            #{conversation_text}
-          PROMPT
-
-          model = @config[:summary_model] || "claude-sonnet-4-20250514"
-          res = @provider.complete(prompt, model: model)
-          res.content
-        end
-      end
+      def call(env) = @app.call(env)
     end
   end
 end
@@ -153,5 +38,36 @@ end
 __END__
 
 describe "brute/middleware/040_compaction_check" do
-  # not implemented
+  it "passes the turn through as it always did, and says what to use instead" do
+    warned = []
+    original = GemKit::Deprecate.method(:warn)
+    GemKit::Deprecate.define_singleton_method(:warn) { |message| warned << message }
+
+    begin
+      # Whatever it was configured with is taken and ignored, so an existing
+      # `use` line keeps parsing.
+      layer = Brute::Middleware::CompactionCheck.new(
+        ->(env) { env[:messages].assistant("answered") },
+        system_prompt: "you are helpful",
+        token_threshold: 100
+      )
+
+      env = { messages: Brute.log }
+      layer.call(env)
+      env[:messages].last.content.should == "answered"
+    ensure
+      GemKit::Deprecate.define_singleton_method(:warn, original)
+    end
+
+    # Not a subclass of its replacement: a layer that compacted nothing must
+    # not start compacting because its name was deprecated.
+    Brute::Middleware::CompactionCheck.ancestors
+      .should.not.include Brute::Middleware::DefaultCompactionPipeline
+
+    warned.first.should.include "Brute::Middleware::DefaultCompactionPipeline"
+
+    declared = GemKit::Deprecate.registry.find { |entry| entry.name == "Brute::Middleware::CompactionCheck" }
+    declared.replacement.should == "Brute::Middleware::DefaultCompactionPipeline"
+    declared.removed_in.should == Gem::Version.new("6.0")
+  end
 end

data/lib/brute/middleware/040_default_compaction_pipeline.rb

@@ -0,0 +1,352 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "brute"
+
+module Brute
+  module Middleware
+    # Compacts the conversation once it fills too much of the model's window.
+    #
+    # This layer owns the *when*: before each call it estimates the size of the
+    # conversation, and once it reaches `compact_at` of the window it asks a
+    # compactor to bring it down to `compact_to`. What is given up, and in what
+    # order, is the compactor's business.
+    #
+    #   use Brute::Middleware::Loop::ToolResult
+    #   use Brute::Middleware::DefaultCompactionPipeline,
+    #     window:     200_000,
+    #     summariser: Brute::Completion::OpenRouter.new(config: { access_token: key })
+    #   use Brute::Middleware::DefaultToolPipeline, tools: tools
+    #
+    # The compactor it builds is the usual ladder, cheapest first:
+    #
+    #   use Brute::Compaction::Middleware::ToolResults     rewrite older tool output
+    #   use Brute::Compaction::Middleware::SlidingWindow   drop the oldest turns, then steps
+    #   run Brute::Compaction::Summarize                   summarise what is left, until it fits
+    #
+    # Pass `compactor:` to say something else. A Brute::Turn::CompactionPipeline
+    # is the usual thing to pass, but anything answering
+    # `#compact(messages, target:)` will do. Passing no summariser leaves the
+    # terminal doing nothing, which is how an agent says it would rather live
+    # with a full context than pay to shrink it.
+    #
+    # It belongs inside the tool loop rather than around it, so it runs before
+    # every call rather than once a turn -- a long run of tool results can fill
+    # the window without the turn ever ending.
+    #
+    # Sizing anchors on what the provider itself counted for the last call and
+    # measures locally only what has been appended since, so the estimate is
+    # exact for the bulk of the conversation and approximate only for its tail.
+    #
+    # Tool schemas ride in every request and are part of what fills a window,
+    # so they are counted too -- against the trigger when nothing has been
+    # reported yet, and off the target the compactor is given, because what
+    # the schemas occupy is not room the conversation may have. This layer
+    # sits above the tool pipeline, so on the very first call of a turn
+    # env[:tools] is not set yet: pass `tools:` to have them counted then.
+    #
+    # Compaction is lossy, and this layer keeps no record of what it gave up:
+    # it rewrites env[:messages] and says so with :compacted. An application
+    # that keeps a transcript preserves it from there.
+    #
+    #   agent.on(:compacted) { |env, payload| archive(env, payload) }
+    #
+    class DefaultCompactionPipeline < Brute::Middleware::Base
+      def initialize(app, window:, summariser: nil, compactor: nil, keep_steps: 2,
+                     compact_at: 0.7, compact_to: 0.4, token_counter: nil, tools: nil)
+        unless compact_to.positive? && compact_to < compact_at && compact_at <= 1
+          raise ArgumentError, "expected 0 < compact_to < compact_at <= 1, got #{compact_to} and #{compact_at}"
+        end
+
+        @app = app
+        @compactor = compactor || self.class.compactor(summariser: summariser, keep_steps: keep_steps)
+        @window = window
+        @compact_at = compact_at
+        @compact_to = compact_to
+        @token_counter = token_counter || Brute::TokenCounter.default
+        @tools = tools
+      end
+
+      def call(env)
+        env[:compactor] = @compactor
+        compact(env)
+        @app.call(env)
+        env
+      end
+
+      # The ladder this layer wires when it is not given one.
+      def self.compactor(summariser: nil, keep_steps: 2)
+        terminal = Declines.new
+
+        unless summariser.nil?
+          terminal = Brute::Compaction::Summarize.new(summariser, keep_steps: keep_steps)
+        end
+
+        Brute::Turn::CompactionPipeline.new do
+          use Brute::Compaction::Middleware::ToolResults, keep_steps: 1
+          use Brute::Compaction::Middleware::SlidingWindow, keep_steps: keep_steps
+
+          run terminal
+        end
+      end
+
+      # The floor of a pipeline given nothing to summarise with: what the free
+      # layers managed is what the turn gets.
+      class Declines
+        def call(env) = env
+      end
+
+      private
+
+        def compact(env)
+          context = estimate(env)
+
+          if context >= @window * @compact_at
+            before = @token_counter.count(env[:messages])
+            compacted = attempt(env, target(env))
+
+            unless compacted.nil?
+              env[:messages].replace(compacted)
+              # The reported total describes a conversation that no longer
+              # exists, so the next estimate must not build on it. The call
+              # below refreshes it; one that fails leaves the estimate to be
+              # counted from scratch instead of anchored to a fiction.
+              env[:metadata]&.delete(:last_llm_usage)
+              emit(
+                COMPACTED_EVENT,
+                env,
+                { context: context, before: before, after: @token_counter.count(compacted) },
+              )
+            end
+          end
+        end
+
+        # What the conversation alone may occupy: the target, less whatever
+        # the schemas are already taking out of it. A window too small to
+        # hold its own tool schemas is a configuration a compactor cannot
+        # fix, so the floor is 1 rather than a negative target.
+        def target(env)
+          [(@window * @compact_to).to_i - schemas(env), 1].max
+        end
+
+        def schemas(env)
+          tools = @tools || env[:tools]
+
+          if tools.nil?
+            0
+          else
+            @token_counter.count([], tools: tools)
+          end
+        end
+
+        # A compactor that raises is a compactor that declined. Compaction is
+        # an optimisation, and an agent that cannot shrink its context should
+        # carry on with the context it has rather than die of it.
+        def attempt(env, target)
+          compacted = nil
+
+          emit(COMPACT_DURATION_EVENT, env, env[:compactor]) do
+            compacted = env[:compactor].compact(
+              env[:messages],
+              target: target,
+              events: env[:events] || Brute::Turn::Pipeline::NullSink.new,
+              token_counter: @token_counter,
+            )
+          end
+
+          compacted
+        rescue => error
+          (env[:events] ||= []) << { type: :error, data: { error: error, message: error.message } }
+          nil
+        end
+
+        # What the provider counted for the last call already covers the
+        # system prompt, the tool schemas and the chat-template overhead, so
+        # only what has landed since it answered needs counting here.
+        def estimate(env)
+          Brute::TokenCounter.estimate(env, counter: @token_counter, tools: @tools || env[:tools])
+        end
+    end
+  end
+end
+
+__END__
+
+describe "brute/middleware/040_default_compaction_pipeline" do
+  def conversation
+    Brute.log.tap do |log|
+      log.user("ask" + ("x" * 1_000))
+      log.assistant("answer" + ("y" * 1_000))
+    end
+  end
+
+  def usage(total) = { last_llm_usage: Brute::UsageDetection::Usage.new(total: total) }
+
+  def history(turns: 4, size: 6_000)
+    Brute.log.tap do |log|
+      log.system("instructions")
+      turns.times do |n|
+        log.user("question #{n}")
+        log << Brute::Message.new(role: :assistant, content: n.to_s * size)
+      end
+      log.user("the current task")
+      log << Brute::Message.new(role: :assistant, content: "z" * size)
+    end
+  end
+
+  def compactor(&block)
+    Object.new.tap do |double|
+      double.define_singleton_method(:compact) { |messages, target:, **| block.call(messages, target) }
+    end
+  end
+
+  it "compacts only once the window fills, and says what the turn gave up" do
+    asked = []
+    events = []
+    shrinks  = compactor { |messages, target| asked << target; messages.first(1) }
+    declines = compactor { |_messages, target| asked << target; nil }
+    raises   = compactor { |_messages, _target| raise IOError, "the summariser is down" }
+
+    layer = lambda do |compactor|
+      Brute::Middleware::DefaultCompactionPipeline.new(
+        ->(env) { env },
+        compactor: compactor,
+        window: 1_000,
+        compact_at: 0.7,
+        compact_to: 0.4,
+      ).tap do |it|
+        it.define_singleton_method(:emit) { |event, _env, *extras, &work| work&.call; events << [event, *extras] }
+      end
+    end
+
+    env = { messages: conversation, metadata: usage(900) }
+    layer.call(shrinks).call(env)
+
+    asked.should == [400]
+    env[:messages].map(&:role).should == [:user]
+    env[:compactor].equal?(shrinks).should.be.true
+    events.select { |e, _| e == :compacted }.should == [[:compacted, { context: 900, before: 514, after: 256 }]]
+    # The attempt is timed, so the compactor that spends a model call is visible.
+    events.select { |e, _| e == :compact_duration }.length.should == 1
+
+    # Sizing anchors on what the provider counted: under compact_at nothing is
+    # asked and nothing is said.
+    asked.clear
+    events.clear
+    layer.call(shrinks).call({ messages: conversation, metadata: usage(600) })
+    asked.should == []
+    events.should == []
+
+    # ...but what landed since it answered is counted on top of it, and that
+    # is what tips this one over.
+    tail = conversation.tap { |log| log.tool("z" * 400, tool_call_id: "tc1") }
+    layer.call(declines).call({ messages: tail, metadata: usage(600) })
+    asked.should == [400]
+
+    # With nothing reported at all, the whole conversation is counted here.
+    asked.clear
+    layer.call(declines).call({ messages: conversation })
+    asked.should == []
+
+    # A compactor that raises is a compactor that declined: reported, not
+    # fatal. An agent that cannot shrink its context carries on with it.
+    failing = { messages: conversation, events: [], metadata: usage(900) }
+    should.not.raise(IOError) { layer.call(raises).call(failing) }
+    failing[:messages].length.should == 2
+    failing[:events].map { |e| [e[:type], e[:data][:message]] }.should == [[:error, "the summariser is down"]]
+
+    # A target at or above the trigger would compact on every single step.
+    should.raise(ArgumentError) do
+      Brute::Middleware::DefaultCompactionPipeline.new(->(e) { e }, compactor: shrinks, window: 10,
+                                                             compact_at: 0.4, compact_to: 0.7)
+    end
+  end
+
+  it "wires the usual ladder, cheapest first, and only pays when the free layers cannot" do
+    rounds = 0
+    summariser = lambda do |env|
+      rounds += 1
+      env[:messages] << Brute::Message.new(role: :assistant, content: "what happened")
+    end
+
+    ladder = Brute::Middleware::DefaultCompactionPipeline.compactor(summariser: summariser, keep_steps: 1)
+    ladder.should.be.kind_of Brute::Turn::CompactionPipeline
+
+    events = []
+    sink = Object.new.tap { |it| it.define_singleton_method(:<<) { |e| events << e; it } }
+
+    messages = history
+    before = Brute::Compaction::Transcript.tokens(messages)
+    out = ladder.compact(messages, target: 1_500, events: sink)
+
+    Brute::Compaction::Transcript.tokens(out).should.be < before
+    events.select { |e| e[:type] == :compacted }.map { |e| e[:data][:strategy] }
+      .should.include "sliding_window"
+
+    # Given no summariser the terminal declines, and the free layers are all
+    # the agent gets -- a policy said out loud rather than configured.
+    free = Brute::Middleware::DefaultCompactionPipeline.compactor(summariser: nil, keep_steps: 1)
+    free.compact(history, target: 1_500).should.not.be.nil
+
+    # One layer, so it still owns the *when* as well as the what.
+    layer = Brute::Middleware::DefaultCompactionPipeline.new(->(e) { e }, window: 1_000, summariser: summariser)
+    layer.define_singleton_method(:emit) { |_e, _env, *, &work| work&.call }
+    env = { messages: history, metadata: {} }
+    layer.call(env)
+    env[:messages].length.should.be < 11
+  end
+
+  it "counts the schemas it will send, and stops anchoring on a conversation that is gone" do
+    asked = []
+    shrinks = compactor { |messages, target| asked << target; messages.first(1) }
+
+    tool = Brute::Turn::ToolPipeline.new(name: "search", description: "search the web. " * 40) do
+      run ->(env) { env[:result] = "" }
+    end
+    schemas = Brute::TokenCounter.default.count([], tools: [tool])
+
+    layer = lambda do |**options|
+      Brute::Middleware::DefaultCompactionPipeline.new(
+        ->(env) { env },
+        compactor: shrinks,
+        window: 1_000,
+        **options,
+      ).tap { |it| it.define_singleton_method(:emit) { |_event, _env, *, &work| work&.call } }
+    end
+
+    # 650 tokens of conversation, nothing reported yet: under the 700 the
+    # window triggers at, so on its own it is left alone.
+    said = -> { Brute.log.tap { |log| log.user("x" * 2_578) } }
+    Brute::TokenCounter.default.count(said.call).should == 650
+
+    layer.call.call({ messages: said.call, metadata: {} })
+    asked.should == []
+
+    # The same conversation ships with tool schemas in every request, and
+    # counting what they occupy is what tips it over. What is left of the
+    # target after them is what the compactor is asked for -- the schemas are
+    # not room the conversation may have.
+    layer.call(tools: [tool]).call({ messages: said.call, metadata: {} })
+    asked.should == [400 - schemas]
+
+    # Reported usage already covers the schemas, so the warm path must not
+    # count them again -- 600 reported and nothing said since is 600, tools
+    # or no tools.
+    asked.clear
+    layer.call(tools: [tool]).call({ messages: conversation, metadata: usage(600) })
+    asked.should == []
+
+    # What the provider counted describes the conversation as it was. Once
+    # compaction has given part of it up that number is a fiction, so it goes
+    # -- the next estimate counts from scratch rather than building on it.
+    compacted = { messages: conversation, metadata: usage(900) }
+    layer.call.call(compacted)
+    compacted[:messages].length.should == 1
+    compacted[:metadata].key?(:last_llm_usage).should.be.false
+
+    # Nothing given up, nothing invalidated.
+    kept = { messages: conversation, metadata: usage(900) }
+    layer.call(compactor: compactor { |_messages, _target| nil }).call(kept)
+    kept[:metadata].key?(:last_llm_usage).should.be.true
+  end
+end