brute 3.2.1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3375f62e8d019bd4a1dd45d2407112ef421c7ce437f604addb0fac51586c5ec
-  data.tar.gz: 15fbc6ed0dce515a143f2424957de3c120ff4f68e5b097d732b418f9fe43aecc
+  metadata.gz: 65f8fa383e8c2d5793cc4ec00023ee6d2117e75535a81676617232b94748f154
+  data.tar.gz: 88f3794d39b79c3c7c03c96f54383fa8647850be1cfc77ae8877fb6ea42aa365
 SHA512:
-  metadata.gz: f2ea1006786ddbb531aaa2bf708f60a362422acf87159f731d7ed459bf409d89103ea48a6530953eb31382eb6ca44ea314afdfb4b61bf870a6153b8128f498cd
-  data.tar.gz: 4ba3e5a9822d3c50b498cab1f33730decc3d3298eb289bd0a450c52e681eaa06fdc002cca73bf0c45b353283e95a0f12ec9cc8605a2623a0f43e1df7eb064789
+  metadata.gz: 57b849d89d406b624fe26dcbc93aa84af2f9b90b12160fb57608938ec53fd7109c87aa3d2c1357620c78f88b9702f797ff106432840a5e4ccaca343f49e7035a
+  data.tar.gz: d73709348a3f205f034389e86950a5ce171d0fd0bf62a9c9e84ad587d3ac322aad211b94d059a93b9b19e16a0c1b6211baebd7f274b88435c1cf61a9a6373007

data/lib/brute/hooks.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "brute"
+
+module Brute
+  # Pub/sub registry for agent lifecycle hooks, subscribed on the builder:
+  #
+  #   Brute.agent
+  #     .use(Brute::Middleware::MaxIterations)
+  #     .run(->(env) { env[:messages].assistant("done") })
+  #     .on(:before_llm) { |env| ... }
+  #     .on(:approve_tool) { |call| call[:name] != "exec" }
+  #
+  # Emission points and payloads:
+  #
+  #   :turn_start, :turn_end  → the turn env (AgentPipeline#start; turn_end
+  #                             fires from an ensure, so it also fires on error)
+  #   :before_llm, :after_llm → the turn env, around every LLM call
+  #   :before_tool            → call env {name:, arguments:, result:, events:,
+  #                             metadata:, turn_env:} — mutate :arguments to
+  #                             rewrite the call, or set :result (or return a
+  #                             value) to skip execution entirely ("respond")
+  #   :approve_tool           → call env — a false return denies the call; a
+  #                             String return denies it with that message
+  #   :after_tool             → call env — mutate :result
+  #
+  # Subscribers run inline (tool events may fire from parallel threads).
+  # Exceptions propagate to the caller — layers that want fail-open semantics
+  # rescue in their own subscriber.
+  class Hooks
+    EVENTS = %i[turn_start turn_end before_llm after_llm before_tool approve_tool after_tool].freeze
+
+    def initialize
+      @subscribers = Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    def on(event, &block)
+      @subscribers[event.to_sym] << block
+      self
+    end
+
+    # Fire an event; returns every subscriber's raw result (nils and false
+    # included — the deny contract distinguishes them).
+    def emit(event, payload)
+      @subscribers[event.to_sym].map { |subscriber| subscriber.call(payload) }
+    end
+
+    def any?(event) = @subscribers[event.to_sym].any?
+  end
+end
+
+__END__
+
+describe "brute/hooks" do
+  it "emits to subscribers in registration order" do
+    hooks = Brute::Hooks.new
+    seen = []
+    hooks.on(:before_llm) { |p| seen << "a#{p}" }
+    hooks.on(:before_llm) { |p| seen << "b#{p}" }
+    hooks.emit(:before_llm, 1)
+    seen.should == ["a1", "b1"]
+  end
+
+  it "returns raw results, false included (deny contract)" do
+    hooks = Brute::Hooks.new
+    hooks.on(:approve_tool) { |_call| false }
+    hooks.emit(:approve_tool, {}).should == [false]
+  end
+
+  it "answers any? and stays chainable" do
+    hooks = Brute::Hooks.new
+    hooks.any?(:turn_start).should.be.false
+    hooks.on(:turn_start) { nil }.should.equal?(hooks)
+    hooks.any?(:turn_start).should.be.true
+  end
+end

data/lib/brute/message_transport/open_router.rb

@@ -3,28 +3,102 @@
 require "bundler/setup"
 require "brute"
 require "brute/message_transport"
+require "json"
 
 module Brute
   class MessageTransport
+    # MessageTransport for the open_router_enhanced gem
+    # (https://github.com/estiens/open_router_enhanced). Brute does not
+    # require it — you do:
+    #
+    #   require "open_router"
     class OpenRouter < MessageTransport
       def self.dump(message)
         message.to_h
       end
 
+      # An OpenRouter::Response's messages (one per choice; in practice
+      # OpenRouter returns exactly one).
+      def messages
+        return @result.choices.map { |choice| choice["message"] || choice[:message] } if @result.respond_to?(:choices)
+
+        super
+      end
+
       private
 
         def wrap(message)
           # Coerce string keys to symbol keys if necessary
           hash = message.to_h.transform_keys(&:to_sym)
-        
+          hash[:role] = hash[:role].to_sym if hash.key?(:role)
+          hash[:tool_calls] = hash[:tool_calls].map { |tc| wrap_tool_call(tc) } if hash[:tool_calls]
+
           case hash
           in { role: (:system | :user | :assistant | :tool) }
-            # Message#initialize handles converting tool_calls & symbolising role!
-            Brute::Message.new(**hash)
+            # Slice away provider extras (refusal, reasoning, model, ...)
+            # that Brute::Message doesn't know.
+            Brute::Message.new(**hash.slice(:role, :content, :tool_calls, :tool_call_id))
           else
             raise "Unrecognised message format #{message.inspect}"
           end
         end
+
+        # An OpenAI-wire tool call ({ id:, type:, function: { name:, arguments: JSON } })
+        # -> the flat { id:, name:, arguments: Hash } Brute::Message understands.
+        def wrap_tool_call(tool_call)
+          tc = tool_call.to_h.transform_keys(&:to_sym)
+          return tc unless tc[:function] # already flat { id:, name:, arguments: }
+
+          function = tc[:function].to_h.transform_keys(&:to_sym)
+          arguments = function[:arguments].to_s
+
+          {
+            id: tc[:id],
+            name: function[:name],
+            arguments: JSON.parse(arguments.empty? ? "{}" : arguments),
+          }
+        end
     end
   end
 end
+
+__END__
+
+describe "brute/message_transport/open_router" do
+  require "brute/messages"
+
+  it "dumps a message to the wire format" do
+    m = Brute::Message.new(role: :user, content: "hi")
+    Brute::MessageTransport::OpenRouter.dump(m).should == { role: :user, content: "hi" }
+  end
+
+  it "wraps a response's choice messages with symbolised roles, dropping provider extras" do
+    fake_response = Struct.new(:choices).new([
+      { "message" => { "role" => "assistant", "content" => "hi there",
+                       "refusal" => nil, "reasoning" => nil, "model" => "openrouter/auto" } },
+    ])
+
+    out = Brute::MessageTransport::OpenRouter.new(fake_response).wrap_each.to_a
+
+    out.size.should == 1
+    out.first.role.should == :assistant
+    out.first.content.should == "hi there"
+  end
+
+  it "unwraps OpenAI-wire tool calls and parses their JSON arguments" do
+    fake_response = Struct.new(:choices).new([
+      { "message" => {
+        "role" => "assistant", "content" => nil,
+        "tool_calls" => [{ "id" => "tc1", "type" => "function",
+                           "function" => { "name" => "shell", "arguments" => '{"command":"ls"}' } }],
+      } },
+    ])
+
+    out = Brute::MessageTransport::OpenRouter.new(fake_response).wrap_each.to_a.first
+
+    out.tool_call?.should.be.true
+    out.tool_calls.first.id.should == "tc1"
+    out.tool_calls.first.name.should == "shell"
+    out.tool_calls.first.arguments.should == { "command" => "ls" }
+  end
+end

data/lib/brute/middleware/025_skills.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "brute"
+
+module Brute
+  module Middleware
+    # Loads skill objects into the agent context.
+    #
+    # Skills are handed in as objects — discovery is the caller's job:
+    #
+    #   skills = Brute::Skill.all(cwd: Dir.pwd)
+    #   agent
+    #     .use(Brute::Middleware::Skills, skills: skills)
+    #     .use(Brute::Middleware::SystemPrompt)
+    #
+    # Per turn:
+    #   1. env[:skills] = the objects, for downstream middleware, tools, and
+    #      the terminal app (prime-agent's resourceLoader.getSkills() analogue)
+    #   2. env[:metadata][:skills] = the same objects, so
+    #      Middleware::SystemPrompt merges them into the prompt ctx and
+    #      Brute::Prompts::Skills renders the <available_skills> section
+    #
+    # Place it before Middleware::SystemPrompt in the stack. It never touches
+    # env[:messages] itself.
+    class Skills
+      def initialize(app, skills: [])
+        @app = app
+        @skills = skills
+      end
+
+      def call(env)
+        env[:skills] = @skills
+        env[:metadata] ||= {}
+        env[:metadata][:skills] ||= @skills
+
+        @app.call(env)
+      end
+    end
+  end
+end
+
+__END__
+
+describe "brute/middleware/025_skills" do
+  def skill(name)
+    Brute::Skill.new(name: name, description: "x", file_path: "/x/#{name}/SKILL.md")
+  end
+
+  def build_middleware(skills: [], &inner)
+    Brute::Middleware::Skills.new(inner || ->(env) { env }, skills: skills)
+  end
+
+  it "stashes skill objects in env[:skills]" do
+    skills = [skill("debugging")]
+    env = { messages: Brute.log, metadata: {} }
+
+    build_middleware(skills: skills).call(env)
+
+    env[:skills].should == skills
+  end
+
+  it "mirrors skills into env[:metadata] for the prompt layer" do
+    skills = [skill("debugging")]
+    env = { messages: Brute.log }
+
+    build_middleware(skills: skills).call(env)
+
+    env[:metadata][:skills].should == skills
+  end
+
+  it "does not clobber an explicit metadata[:skills]" do
+    explicit = [skill("explicit")]
+    env = { messages: Brute.log, metadata: { skills: explicit } }
+
+    build_middleware(skills: [skill("other")]).call(env)
+
+    env[:metadata][:skills].should == explicit
+    env[:skills].map(&:name).should == ["other"]
+  end
+
+  it "defaults to an empty list and passes control down the chain" do
+    called = false
+    env = { messages: Brute.log }
+
+    build_middleware { |e| called = true }.call(env)
+
+    env[:skills].should == []
+    called.should.be.true
+  end
+end

data/lib/brute/middleware/070_tool_pipeline.rb

@@ -48,23 +48,56 @@ module Brute
                 name = tool_call.name.to_sym
                 args = tool_call.arguments
 
-                available_tools[name].call(args).then do |result|
-
-                  # Coerce to String so Hash results (e.g. Shell's
-                  # {stdout:, stderr:, exit_code:}) serialize predictably.
-                  if result.is_a?(String)
-                    content = result
-                  else
-                    content = result.to_s
+                # Lifecycle hooks (Brute::Hooks): before_tool may rewrite
+                # :arguments or short-circuit with a :result; approve_tool
+                # denies on a false (or String) return; after_tool may
+                # rewrite :result.
+                call_env = {
+                  name:      name.to_s,
+                  arguments: args,
+                  result:    nil,
+                  events:    env[:events],
+                  metadata:  {},
+                  turn_env:  env,
+                }
+                if (hooks = env[:hooks])
+                  responses = hooks.emit(:before_tool, call_env).compact
+                  call_env[:result] = responses.last if call_env[:result].nil? && !responses.empty?
+
+                  if call_env[:result].nil?
+                    denial = hooks.emit(:approve_tool, call_env).find { |r| r == false || r.is_a?(String) }
+                    unless denial.nil?
+                      call_env[:result] = denial.is_a?(String) ? denial : %(Tool call to "#{name}" was denied.)
+                    end
                   end
+                end
 
-                  # Universal truncation safety net — skip if already truncated
-                  unless Brute::Truncation.already_truncated?(content)
-                    content = Brute::Truncation.truncate(content)
-                  end
+                result = if call_env[:result].nil?
+                           available_tools[name].call(call_env[:arguments])
+                         else
+                           call_env[:result]
+                         end
+
+                if (hooks = env[:hooks])
+                  call_env[:result] = result
+                  hooks.emit(:after_tool, call_env)
+                  result = call_env[:result]
+                end
+
+                # Coerce to String so Hash results (e.g. Shell's
+                # {stdout:, stderr:, exit_code:}) serialize predictably.
+                if result.is_a?(String)
+                  content = result
+                else
+                  content = result.to_s
+                end
 
-                  results << [tool_call, content]
+                # Universal truncation safety net — skip if already truncated
+                unless Brute::Truncation.already_truncated?(content)
+                  content = Brute::Truncation.truncate(content)
                 end
+
+                results << [tool_call, content]
               rescue => e
                 # Capture the error as a tool result so the LLM can see it
                 # and reason about the failure, rather than crashing the
@@ -141,6 +174,70 @@ describe "brute/middleware/070_tool_pipeline" do
     seen.should == [tool]
   end
 
+  # --- lifecycle hooks (Brute::Hooks) ---
+
+  def hook_env(hooks)
+    { messages: Brute.log, events: [], hooks: hooks }
+  end
+
+  it "before_tool may rewrite arguments and short-circuit with a result" do
+    tool = { name: "echo", description: "", execute: ->(text:) { "ran:#{text}" } }
+    inner = ->(env) do
+      env[:messages] << Brute::Message.new(role: :assistant, content: "",
+        tool_calls: [{ id: "tc1", name: "echo", arguments: { "text" => "orig" } }])
+    end
+    hooks = Brute::Hooks.new
+    hooks.on(:before_tool) { |call| call[:arguments] = { text: "rewritten" }; nil }
+    mw = Brute::Middleware::ToolPipeline.new(inner, tools: [tool])
+    env = hook_env(hooks)
+    env[:messages].user("hi")
+    mw.call(env)
+    env[:messages].last.content.should == "ran:rewritten"
+
+    hooks2 = Brute::Hooks.new
+    hooks2.on(:before_tool) { |_call| "canned" }
+    mw2 = Brute::Middleware::ToolPipeline.new(inner, tools: [tool])
+    env2 = hook_env(hooks2)
+    env2[:messages].user("hi")
+    mw2.call(env2)
+    env2[:messages].last.content.should == "canned" # never executed
+  end
+
+  it "approve_tool denies on false (generic message) or String (custom)" do
+    tool = { name: "exec", description: "", execute: ->(**) { "ran" } }
+    inner = ->(env) do
+      env[:messages] << Brute::Message.new(role: :assistant, content: "",
+        tool_calls: [{ id: "tc1", name: "exec", arguments: {} }])
+    end
+    hooks = Brute::Hooks.new
+    hooks.on(:approve_tool) { |_call| false }
+    env = hook_env(hooks)
+    env[:messages].user("hi")
+    Brute::Middleware::ToolPipeline.new(inner, tools: [tool]).call(env)
+    env[:messages].last.content.should == %(Tool call to "exec" was denied.)
+
+    hooks2 = Brute::Hooks.new
+    hooks2.on(:approve_tool) { |_call| "denied by policy" }
+    env2 = hook_env(hooks2)
+    env2[:messages].user("hi")
+    Brute::Middleware::ToolPipeline.new(inner, tools: [tool]).call(env2)
+    env2[:messages].last.content.should == "denied by policy"
+  end
+
+  it "after_tool may rewrite the result" do
+    tool = { name: "echo", description: "", execute: ->(**) { "raw" } }
+    inner = ->(env) do
+      env[:messages] << Brute::Message.new(role: :assistant, content: "",
+        tool_calls: [{ id: "tc1", name: "echo", arguments: {} }])
+    end
+    hooks = Brute::Hooks.new
+    hooks.on(:after_tool) { |call| call[:result] = "rewrote(#{call[:result]})" }
+    env = hook_env(hooks)
+    env[:messages].user("hi")
+    Brute::Middleware::ToolPipeline.new(inner, tools: [tool]).call(env)
+    env[:messages].last.content.should == "rewrote(raw)"
+  end
+
   # --- Universal output truncation ---
 
   it "truncates large tool results via Truncation" do

data/lib/brute/middleware/open_router.rb

@@ -4,29 +4,104 @@ module Brute
   module Middleware
     module OpenRouter
       class Completion
+        # config:   keyword arguments for OpenRouter::Client.new
+        #           (access_token:, request_timeout:, uri_base:, extra_headers:).
+        #           Defaults to OpenRouter.configuration's global settings.
+        # options:  keyword arguments for OpenRouter::CompletionOptions.new
+        #           (model:, temperature:, tools:, ...).
         def initialize(app, config: {}, **options)
           @app = app
-          @config = ::OpenRouter::Configuration.new(config)
-          @options = ::OpenRouter::CompletionOptions.new(options)
+          @config = config
+          @options = ::OpenRouter::CompletionOptions.new(**options)
         end
 
         def call(env)
+          env[:hooks]&.emit(:before_llm, env)
+
           messages = Brute::MessageTransport::OpenRouter.dump_all(env[:messages])
 
-          ::OpenRouter::Client.new(@config).then do |client|
+          ::OpenRouter::Client.new(**@config).then do |client|
             client.complete(messages, @options).then do |response|
 
+              # Expose the provider's usage for downstream accounting
+              # middleware (goal budgets, autonomous limits, compaction
+              # thresholds, usage attribution) — additive metadata only.
+              if response.respond_to?(:usage) && response.usage
+                (env[:metadata] ||= {})[:last_llm_usage] = response.usage
+              end
+
               # OpenRouter in fact only returns a single message...
-              # https://github.com/estiens/open_router_enhanced/blob/main/lib/open_router/response.rb#L66
+              # https://github.com/estiens/open_router_enhanced/blob/main/lib/open_router/response.rb
               Brute::MessageTransport::OpenRouter.wrap_each(response) do |message|
                 env[:messages] << message
               end
             end
           end
 
+          env[:hooks]&.emit(:after_llm, env)
           env
         end
       end
     end
   end
 end
+
+__END__
+
+describe "brute/middleware/open_router" do
+  require "brute/messages"
+
+  # The repo suite has no open_router gem; stub the two constants the
+  # middleware touches (the transport wraps duck-typed responses fine).
+  begin
+    require "open_router"
+  rescue LoadError
+    module OpenRouter
+      CompletionOptions = Class.new { def initialize(**_opts); end }
+      Client = Class.new
+    end
+  end
+
+  FakeUsageResponse = Struct.new(:usage) do
+    def choices
+      [{ "message" => { "role" => "assistant", "content" => "hello" } }]
+    end
+  end
+
+  it "records the provider usage into env metadata and appends the message" do
+    response = FakeUsageResponse.new({ "prompt_tokens" => 10, "completion_tokens" => 5, "total_tokens" => 15 })
+    fake_client = Object.new
+    fake_client.define_singleton_method(:complete) { |_messages, _options| response }
+    original = OpenRouter::Client.method(:new)
+    OpenRouter::Client.define_singleton_method(:new) { |**_config| fake_client }
+    begin
+      middleware = Brute::Middleware::OpenRouter::Completion.new(->(env) { env })
+      env = { messages: Brute.log }
+      env[:messages].user("hi")
+      middleware.call(env)
+
+      env[:messages].last.role.should == :assistant
+      env[:metadata][:last_llm_usage]["total_tokens"].should == 15
+    ensure
+      OpenRouter::Client.define_singleton_method(:new, original)
+    end
+  end
+
+  it "leaves metadata alone when the response has no usage" do
+    response = FakeUsageResponse.new(nil)
+    fake_client = Object.new
+    fake_client.define_singleton_method(:complete) { |_messages, _options| response }
+    original = OpenRouter::Client.method(:new)
+    OpenRouter::Client.define_singleton_method(:new) { |**_config| fake_client }
+    begin
+      middleware = Brute::Middleware::OpenRouter::Completion.new(->(env) { env })
+      env = { messages: Brute.log }
+      env[:messages].user("hi")
+      middleware.call(env)
+
+      env.key?(:metadata).should.be.false
+    ensure
+      OpenRouter::Client.define_singleton_method(:new, original)
+    end
+  end
+end

data/lib/brute/prompt_template.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "brute"
+require "erb"
+
+module Brute
+  # An ERB-backed system-prompt object for Middleware::SystemPrompt — the
+  # open alternative to Brute::SystemPrompt's built-in section stacks. You
+  # bring a template and named values; every keyword becomes an attr_accessor
+  # and an ERB local of the same name:
+  #
+  #   prompt = Brute::PromptTemplate.new(
+  #     "prompt.erb",
+  #     identity: "You are Pico.",
+  #     memory:   -> { File.read("memory/MEMORY.md") },   # zero-arity proc
+  #     env:      ->(ctx) { Brute::Prompts::Environment.call(ctx) },
+  #   )
+  #   prompt.identity = "You are Brute."   # attr_accessor per section
+  #
+  #   Brute.agent.use(Brute::Middleware::SystemPrompt, system_prompt: prompt)
+  #
+  # Proc values are re-evaluated on every prepare (zero-arity procs are
+  # called with no arguments, others receive the turn ctx), and a template
+  # path is re-read from disk each time — so file-backed sections hot-reload
+  # between turns. The prepare(ctx) -> Result(#empty?, #to_s) contract is
+  # what Middleware::SystemPrompt expects.
+  class PromptTemplate
+    Result = Struct.new(:text) do
+      def to_s = text.to_s
+      def empty? = text.to_s.strip.empty?
+    end
+
+    def initialize(template, **sections)
+      @template = template
+      @section_keys = []
+      sections.each { |key, value| self[key] = value }
+    end
+
+    def [](key)
+      public_send(key)
+    end
+
+    def []=(key, value)
+      unless respond_to?(key)
+        singleton_class.class_eval { attr_accessor key }
+        @section_keys << key
+      end
+      public_send("#{key}=", value)
+    end
+
+    # Called once per turn by Middleware::SystemPrompt.
+    def prepare(ctx = {})
+      Result.new(render(locals(ctx)))
+    end
+
+    private
+
+    def locals(ctx)
+      @section_keys.to_h do |key|
+        value = self[key]
+        resolved = value.is_a?(Proc) ? (value.arity.zero? ? value.call : value.call(ctx)) : value
+        [key, resolved]
+      end.merge(ctx: ctx)
+    end
+
+    def render(values)
+      context = binding
+      values.each { |key, value| context.local_variable_set(key, value) }
+      ERB.new(template_source, trim_mode: "-").result(context)
+    end
+
+    # A path that exists is re-read every time; anything else is treated as
+    # an inline ERB source string.
+    def template_source
+      File.exist?(@template.to_s) ? File.read(@template) : @template.to_s
+    end
+  end
+end
+
+__END__
+
+describe "brute/prompt_template" do
+  require "tmpdir"
+
+  it "renders keyword sections as ERB locals" do
+    prompt = Brute::PromptTemplate.new("Hello <%= name %>, <%= mood %> today.", name: "Pico", mood: "happy")
+    prompt.prepare.to_s.should == "Hello Pico, happy today."
+  end
+
+  it "exposes an attr_accessor per section" do
+    prompt = Brute::PromptTemplate.new("<%= name %>", name: "Pico")
+    prompt.name.should == "Pico"
+    prompt.name = "Brute"
+    prompt.prepare.to_s.should == "Brute"
+  end
+
+  it "re-evaluates zero-arity procs on every prepare" do
+    count = 0
+    prompt = Brute::PromptTemplate.new("<%= tick %>", tick: -> { count += 1 })
+    prompt.prepare.to_s.should == "1"
+    prompt.prepare.to_s.should == "2"
+  end
+
+  it "passes ctx to procs that take an argument" do
+    prompt = Brute::PromptTemplate.new("<%= who %>", who: ->(ctx) { ctx[:agent] })
+    prompt.prepare(agent: "pico").to_s.should == "pico"
+  end
+
+  it "re-reads a template file on every prepare" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "prompt.erb")
+      File.write(path, "v1 <%= x %>")
+      prompt = Brute::PromptTemplate.new(path, x: "a")
+      prompt.prepare.to_s.should == "v1 a"
+      File.write(path, "v2 <%= x %>")
+      prompt.prepare.to_s.should == "v2 a"
+    end
+  end
+
+  it "honours the Result contract (empty?/to_s)" do
+    Brute::PromptTemplate.new("").prepare.empty?.should.be.true
+    Brute::PromptTemplate.new("hi").prepare.empty?.should.be.false
+  end
+end