openlanes 3.0.0

data/evals/cases/yoda-writer/spec-medium/fail/plan/spec.md

@@ -0,0 +1,45 @@
+# Cart Quantity Limits
+
+Customers of Example Corp's shop can add negative or absurd quantities to a cart.
+
+## What research needs to settle
+
+1. Where is quantity validated today?
+
+## Research
+
+1. Nowhere. `lib/cart.rb:4` stores whatever `add` receives.
+2. The checkout service rejects quantities above 99 with a 422 (`lib/checkout.rb:12`).
+
+### Could not settle
+
+1. Whether zero should remove the line or be rejected.
+
+## Goal
+
+Validate quantities in the cart.
+
+## Non-Goals
+
+- Changing the checkout limit.
+
+## In scope
+
+- Handles errors.
+
+## Out of scope
+
+- Bulk orders.
+
+## Back end / front end
+
+All back end.
+
+## Open questions
+
+None.
+
+> [!NOTE]
+>
+> [2026-09-04 12:02:11 PM PDT] [ agent: yoda-writer   status: Started, round 1 ]
+> [2026-09-04 12:04:02 PM PDT] [ agent: yoda-writer   status: Completed, round 1 ]

data/evals/cases/yoda-writer/spec-medium/fail/run.json

@@ -0,0 +1 @@
+{"seconds": 111, "tokens": 21900, "state": "ready_for_planning"}

data/evals/cases/yoda-writer/spec-medium/pass/plan/spec.md

@@ -0,0 +1,63 @@
+# Cart Quantity Limits
+
+Customers of Example Corp's shop can add negative or absurd quantities to a cart.
+
+## What research needs to settle
+
+1. Where is quantity validated today?
+
+## Research
+
+1. Nowhere. `lib/cart.rb:4` stores whatever `add` receives.
+2. The checkout service rejects quantities above 99 with a 422 (`lib/checkout.rb:12`).
+
+### Could not settle
+
+1. Whether zero should remove the line or be rejected.
+
+## Goal
+
+A cart can only ever hold quantities the checkout will accept, so a customer learns about a bad quantity when they type it rather than at payment. Framed two ways, as a validation problem in `Cart#add` or as a contract shared with checkout, the second wins: the limit already lives in `lib/checkout.rb:12`, and copying it would let the two drift.
+
+## Non-Goals
+
+- Changing the checkout limit of 99.
+- Per-product stock limits; stock is a separate system.
+- Changing how the cart is persisted.
+- Localising the error message beyond English.
+
+## In scope
+
+- `Cart#add` with a quantity below 1 raises `Cart::InvalidQuantity` and leaves the cart unchanged; a spec proves it.
+- `Cart#add` with a quantity above the checkout limit raises the same error; the limit is read from `Checkout::MAX_QUANTITY`.
+- The cart page shows the error next to the quantity field, and the field keeps the rejected value.
+
+## Out of scope
+
+- Bulk orders above 99: they need a sales contact flow, which is a product decision.
+- Backfilling existing carts that already hold bad quantities: none exist in production per the research.
+
+## Back end / front end
+
+| Item | Half |
+| --- | --- |
+| `Cart#add` validation and the shared constant | luke-backend |
+| Error display on the cart page | rey-frontend |
+
+## Open questions
+
+1. Whether zero removes the line or is rejected (leah could not settle it). Assumed: rejected.
+
+## Risks
+
+- The checkout constant is private today; making it public touches a file another team owns.
+
+## Conclusion
+
+When this ships, a cart cannot hold a quantity checkout would refuse, the limit is defined once, and the customer sees the problem on the cart page.
+
+> [!NOTE]
+>
+> [2026-09-04 12:02:11 PM PDT] [ agent: yoda-writer   status: Started, round 1 ]
+> [2026-09-04 12:09:40 PM PDT] [ agent: yoda-writer   status: Completed, round 1 ]
+> [2026-09-04 12:09:41 PM PDT] [ next: palpatine-planner ]

data/evals/cases/yoda-writer/spec-medium/pass/run.json

@@ -0,0 +1 @@
+{"seconds": 449, "tokens": 96200, "state": "ready_for_planning"}

data/evals/cases/yoda-writer/spec-medium.yml

@@ -0,0 +1,40 @@
+id: spec-medium
+agent: yoda-writer
+depth: medium
+description: >
+  A researched spec. yoda must write every section of a full specification,
+  at least three Non-Goals, and leave plan.md blank for the planner; a
+  heading in plan.md would claim the plan was already written.
+fixture:
+  state: researched
+  slug: cart-quantity-limits
+  files:
+    spec.md: |
+      # Cart Quantity Limits
+
+      Customers of Example Corp's shop can add negative or absurd quantities to a cart.
+
+      ## What research needs to settle
+
+      1. Where is quantity validated today?
+
+      ## Research
+
+      1. Nowhere. `lib/cart.rb:4` stores whatever `add` receives.
+      2. The checkout service rejects quantities above 99 with a 422 (`lib/checkout.rb:12`).
+
+      ### Could not settle
+
+      1. Whether zero should remove the line or be rejected.
+expect:
+  state: ready_for_planning
+  signed: true
+  files_exist: [plan.md]
+  sections:
+    spec.md: [Goal, Non-Goals, In scope, Out of scope, Back end / front end, Open questions, Risks, Conclusion]
+  depth:
+    medium:
+      words: { file: spec.md, min: 250, max: 2500 }
+      count: { file: spec.md, section: Non-Goals, pattern: '^[ \t]*(?:[-*]|\d+\.)[ \t]', min: 3, max: 8 }
+      max_seconds: 900
+      max_tokens: 150000

data/exe/depot

@@ -0,0 +1 @@
+openlanes

data/exe/lanes

@@ -0,0 +1 @@
+openlanes

data/exe/openlanes

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# openlanes — spec → plan → build.
+#
+# Every command does the work it is named for; -n / --dry-run previews it.
+#
+# © 2026 Konstantin Gredeskoul
+
+# Resolve the dependencies from this repository without the bundler, thank you very much.
+module OpenLanes
+  PROJECT_ROOT = File.expand_path("..", __dir__)
+end
+
+if OpenLanes::PROJECT_ROOT.include?("lib/ruby/gems")
+  require "rubygems"
+  gem "openlanes"
+end
+
+# lib/ goes first on the load path: several files `require "openlanes/..."`,
+# and without this those resolve to whichever openlanes gem is installed,
+# not to this checkout, and one class ends up defined twice.
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+
+require_relative "../lib/openlanes"
+require_relative "../lib/openlanes/launcher"
+
+begin
+  OpenLanes::Launcher.new(ARGV.dup).execute!
+rescue SystemExit => e
+  exit(e.status)
+end

data/lib/openlanes/adapters/base.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module OpenLanes
+  module Adapters
+    # What every adapter answers. A subclass overrides {#argv}; the rest has a
+    # default that is right for a CLI with no opinions of its own.
+    class Base
+      # @return [String] the name agent frontmatter uses
+      def name = self.class.name.split("::").last.downcase
+
+      # @return [String] the executable, for messages
+      def executable = name
+
+      # @param invocation [OpenLanes::Adapters::Invocation]
+      # @return [Array<String>]
+      def argv(invocation) = raise NotImplementedError, "#{self.class} must build an argv for #{invocation.class}"
+
+      # A parser for what this CLI prints, with the same interface as
+      # {OpenLanes::Execution::Transcript}.
+      #
+      # @param trace [String, nil] where to keep every line verbatim
+      # @return [#push, #finish, #up, #down, #failed?]
+      def transcript(trace: nil, &) = Stream.new(trace:, &)
+
+      # The model to ask for, after any ceiling this CLI imposes.
+      #
+      # @param model [String, nil]
+      # @return [String, nil]
+      def model(model) = model
+
+      # @param effort [String, nil] one of {EFFORTS}
+      # @return [String, nil] this CLI's word for it
+      def effort(effort) = effort
+
+      # What the child process gets on top of the harness's own environment.
+      #
+      # @return [Hash{String => String}]
+      def environment = {}
+
+      # The models this CLI offers, most capable first, for the page's
+      # dropdowns and the cost meter. Empty for a CLI nobody has priced.
+      #
+      # @return [Array<OpenLanes::Adapters::Model>]
+      def models = []
+
+      # @param name [String, nil] an alias or a full id
+      # @return [OpenLanes::Adapters::Model, nil]
+      def model_entry(name) = models.find { |m| m.id == name.to_s }
+
+      # What, sent into a resumed session, makes this CLI compact it (W28);
+      # nil for a CLI that cannot resume one, whose agents are therefore never
+      # compacted mid-round.
+      #
+      # @return [String, nil]
+      def compact_prompt = nil
+
+      # @return [Boolean] whether an agent on this CLI can be compacted and
+      #   carried on in the same session
+      def compacts? = !compact_prompt.nil?
+
+      # Whether the CLI itself refuses the denied tools, rather than only being
+      # asked not to use them. The prompt says which, because telling an agent
+      # a guard exists when it does not is how it stops being careful.
+      #
+      # @return [Boolean]
+      def enforces_tool_denial? = false
+    end
+  end
+end

data/lib/openlanes/adapters/claude.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module OpenLanes
+  module Adapters
+    # `claude -p`, streaming JSON.
+    class Claude < Base
+      # Models by capability, cheapest first. Anything ranked above
+      # {CEILING} is asked for as the ceiling instead: a run that quietly
+      # spends Fable money on a task Opus does fine is a run nobody budgeted.
+      LADDER = %w[haiku sonnet opus fable].freeze
+
+      # The most expensive model any agent may run on.
+      CEILING = "opus"
+
+      # Every Claude model priced, most capable first, newest first within a
+      # tier. The one place a model id, its label and its rates are written:
+      # the dropdown, the cost meter and alias resolution all read it, through
+      # {#models}, which offers only what {CEILING} lets run. Rates are base
+      # dollars per million tokens, in and out, from
+      # https://platform.claude.com/docs/en/about-claude/pricing as read on
+      # 2026-10-13. Haiku 5.5 is priced for prompts up to 100k tokens; above
+      # that it is $0.50 in and $2.50 out, which this table does not model.
+      CATALOGUE = [
+        Model.new(id: "claude-fable-5-1", label: "Fable 5.1", rate_in: 10, rate_out: 50),
+        Model.new(id: "claude-opus-5-5", label: "Opus 5.5", rate_in: 4, rate_out: 20),
+        Model.new(id: "claude-opus-5", label: "Opus 5", rate_in: 5, rate_out: 25),
+        Model.new(id: "claude-sonnet-5-5", label: "Sonnet 5.5", rate_in: 2, rate_out: 10),
+        Model.new(id: "claude-sonnet-5", label: "Sonnet 5", rate_in: 2, rate_out: 10),
+        Model.new(id: "claude-haiku-5-5", label: "Haiku 5.5", rate_in: 0.10, rate_out: 0.50)
+      ].freeze
+
+      # What an agent may actually run on: the catalogue below {CEILING}. A
+      # model the CLI would be asked for as something cheaper is not offered,
+      # so the page never shows a choice that will not happen.
+      MODELS = CATALOGUE.select { |m| LADDER.index { |tier| m.id.include?(tier) } <= LADDER.index(CEILING) }.freeze
+
+      # The tier `claude` runs when an agent names no model, so an unnamed
+      # model is still priced rather than shown as free.
+      UNNAMED = "sonnet"
+
+      # The variable `claude` reads its autocompact threshold from, as a
+      # percentage. Found in the 2.1.x binary, where `Vle()` reads it with
+      # `parseFloat(process.env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE)`.
+      AUTOCOMPACT_VARIABLE = "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE"
+
+      # Flags that keep the operator's personal setup out of the agent. The
+      # project's CLAUDE.md and settings still load. Measured on a one-word
+      # prompt: 143 tools, 60 MCP servers, 358 skills and 17 hook events
+      # without these; 28 tools and none of the rest with them, at three
+      # quarters of the context and half the start-up time.
+      LEAN = ["--setting-sources", "project,local",
+              "--strict-mcp-config", "--mcp-config", '{"mcpServers":{}}',
+              "--disable-slash-commands"].freeze
+
+      # The one flag of {LEAN} a compaction drops: with it, `claude -p
+      # --resume <id> "/compact"` answers "/compact isn't available in this
+      # environment" and compacts nothing (measured on 2.1.x).
+      SLASH_COMMANDS_OFF = "--disable-slash-commands"
+
+      # @param invocation [OpenLanes::Adapters::Invocation]
+      # @return [Array<String>]
+      def argv(invocation)
+        # `--include-partial-messages` is what the token meter runs on. Without
+        # it the stream reports a settled input count and a placeholder output
+        # count — 2 for a four-thousand-token answer — and a spinner counting
+        # what came back would read zero all run.
+        argv = ["claude", "-p", invocation.prompt, "--add-dir", invocation.root,
+                "--output-format", "stream-json", "--verbose", "--include-partial-messages", "--brief"]
+        argv += ["--resume", invocation.resume] if invocation.resume
+        argv += LEAN.reject { invocation.slash_commands && it == SLASH_COMMANDS_OFF } if invocation.lean
+        argv += ["--disallowedTools", invocation.denied_tools.join(",")] unless invocation.denied_tools.empty?
+        argv += ["--allowedTools", invocation.allowed_tools.join(",")] unless invocation.allowed_tools.empty?
+        model = model(invocation.model)
+        argv += ["--model", model] if model
+        argv += ["--effort", invocation.effort] if invocation.effort
+        argv
+      end
+
+      # @return [OpenLanes::Execution::Transcript]
+      def transcript(trace: nil, &) = Execution::Transcript.new(trace:, &)
+
+      # @param model [String, nil] an alias (`sonnet`) or a full id
+      #   (`claude-fable-5-1`)
+      # @return [String, nil]
+      def model(model)
+        return model if model.nil? || model.to_s.empty?
+
+        rank = LADDER.index { |tier| model.to_s.include?(tier) }
+        rank && rank > LADDER.index(CEILING) ? CEILING : model.to_s
+      end
+
+      # @return [Boolean]
+      def enforces_tool_denial? = true
+
+      # `claude -p --resume <id> "/compact"` compacts the session and prints a
+      # `compact_boundary` event; the agent cannot run it on itself, because
+      # `/compact` is the caller's command, not a tool.
+      #
+      # @return [String]
+      def compact_prompt = "/compact"
+
+      # @return [Hash{String => String}]
+      def environment = { AUTOCOMPACT_VARIABLE => AUTOCOMPACT.to_s }
+
+      # @return [Array<OpenLanes::Adapters::Model>]
+      def models = MODELS
+
+      # A full id as itself; an alias that is exactly a tier (`opus`) as the
+      # newest model of that tier, the first in {MODELS} to carry its name;
+      # no name as {UNNAMED}. Anything else, `not-opus` or `sonnet-old`
+      # included, is no model at all.
+      #
+      # @param name [String, nil]
+      # @return [OpenLanes::Adapters::Model, nil]
+      def model_entry(name)
+        text = name.to_s
+        text = UNNAMED if text.empty? || text == "default"
+        return MODELS.find { |m| m.id.match?(/\Aclaude-#{text}-/) } if LADDER.include?(text)
+
+        MODELS.find { |m| m.id == text }
+      end
+    end
+  end
+end

data/lib/openlanes/adapters/codex.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module OpenLanes
+  module Adapters
+    # `codex exec --json`, inside codex's own workspace-write sandbox.
+    #
+    # The sandbox has no network unless the agent declares `network: true`,
+    # which is the same default the Claude adapter gets from withholding
+    # WebFetch and WebSearch. Codex has no per-command denylist, so the
+    # forbidden commands are stated in the prompt and the after-check (HEAD
+    # unmoved, no new remote ref) is what actually holds the line.
+    class Codex < Base
+      # Codex says `xhigh` for the top of its scale and has no `max`.
+      EFFORT = { "low" => "low", "medium" => "medium", "high" => "high", "xhigh" => "xhigh", "max" => "xhigh" }.freeze
+
+      # @param invocation [OpenLanes::Adapters::Invocation]
+      # @return [Array<String>]
+      def argv(invocation)
+        argv = ["codex", "exec", "--json", "--sandbox", "workspace-write", "--cd", invocation.root]
+        argv << "--ignore-user-config" if invocation.lean
+        argv += ["--model", invocation.model] if invocation.model
+        effort = effort(invocation.effort)
+        argv += ["--config", %(model_reasoning_effort="#{effort}")] if effort
+        argv += ["--config", "sandbox_workspace_write.network_access=true"] if invocation.network
+        argv << invocation.prompt
+      end
+
+      # @param effort [String, nil]
+      # @return [String, nil]
+      def effort(effort) = effort && EFFORT[effort.to_s]
+    end
+  end
+end

data/lib/openlanes/adapters/model.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module OpenLanes
+  module Adapters
+    # One model an adapter offers: what the page lists in a car's dropdown,
+    # and what a token costs on it.
+    #
+    # @!attribute [r] id
+    #   @return [String] the full model id, e.g. `claude-sonnet-5-5`
+    # @!attribute [r] label
+    #   @return [String] e.g. `Sonnet 5.5`
+    # @!attribute [r] rate_in
+    #   @return [Numeric] dollars per million tokens sent
+    # @!attribute [r] rate_out
+    #   @return [Numeric] dollars per million tokens generated
+    # @!attribute [r] context
+    #   @return [Integer] tokens the model's context window holds, the
+    #     ceiling a car's context meter is drawn against
+    Model = Data.define(:id, :label, :rate_in, :rate_out, :context) do
+      def initialize(context: Model::WINDOW, **rest) = super
+
+      # @param up [Integer] tokens in
+      # @param down [Integer] tokens out
+      # @return [Float] dollars
+      def cost(up, down) = ((up.to_i * rate_in) + (down.to_i * rate_out)) / 1_000_000.0
+
+      # The `ModelChoice` of `web/src/api/types.ts`.
+      #
+      # @return [Hash]
+      def wire = { id:, label:, rates: { in: rate_in, out: rate_out } }
+    end
+
+    # The context window a model gets when its entry names none: every
+    # model the adapters price today holds this many tokens.
+    Model::WINDOW = 200_000
+  end
+end

data/lib/openlanes/adapters/pi.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module OpenLanes
+  module Adapters
+    # `pi -p --mode json`. Pi has no sandbox and no per-command denylist, so
+    # the after-check is the only guard, and the prompt says as much.
+    class Pi < Base
+      # Pi's `--thinking` scale already uses these words.
+      THINKING = Adapters::EFFORTS
+
+      # @param invocation [OpenLanes::Adapters::Invocation]
+      # @return [Array<String>]
+      def argv(invocation)
+        argv = ["pi", "--print", "--mode", "json", "--no-session"]
+        argv += ["--no-extensions", "--no-skills", "--no-prompt-templates"] if invocation.lean
+        argv += ["--model", invocation.model] if invocation.model
+        argv += ["--thinking", invocation.effort] if THINKING.include?(invocation.effort.to_s)
+        argv << invocation.prompt
+      end
+    end
+  end
+end

data/lib/openlanes/adapters/stream.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "json"
+
+module OpenLanes
+  module Adapters
+    # A transcript for a CLI that prints JSON lines in a schema this harness
+    # was not written against: `codex exec --json`, `pi --mode json`.
+    #
+    # It answers everything {OpenLanes::Execution::Transcript} answers, but
+    # it reads events by shape rather than by name. Any `usage` object with
+    # `input_tokens` and `output_tokens` moves the meter; any event whose
+    # type mentions a tool, a command or an exec counts as a tool call; any
+    # event typed as an error or a failure is the error. A CLI that renames
+    # its events keeps working, and one that stops reporting usage shows a
+    # meter at zero rather than a crash.
+    class Stream
+      # @param trace [String, nil] where every line is kept verbatim
+      # @yieldparam progress [OpenLanes::Execution::Transcript::Progress]
+      def initialize(trace: nil, &on_progress)
+        @on_progress = on_progress
+        @buffer = +""
+        @plain = []
+        @trace_path = trace
+        @trace = trace && File.open(trace, "a")
+        @up = 0
+        @down = 0
+        @cached = 0
+        @tools = 0
+        @activity = nil
+        @result = nil
+        @error = nil
+      end
+
+      # @return [Integer] tokens sent, cached input included
+      attr_reader :up
+
+      # @return [Integer] tokens generated
+      attr_reader :down
+
+      # @return [Integer] of {#up}, input the CLI reports as served from cache
+      attr_reader :cached
+
+      # @return [Integer]
+      attr_reader :tools
+
+      # @return [String, nil]
+      attr_reader :activity
+
+      # @return [String, nil] the last thing the agent said
+      attr_reader :result
+
+      # @return [Array<String>] lines that were not JSON
+      attr_reader :plain
+
+      # @return [String, nil]
+      attr_reader :error
+
+      # @return [String, nil]
+      attr_reader :trace_path
+
+      # @return [Integer, nil]
+      attr_accessor :pid
+
+      # These CLIs do not report sub-agents.
+      #
+      # @return [Integer]
+      def spawned = 0
+
+      # @return [Integer]
+      def delegated = 0
+
+      # @return [String, nil] nothing is sent through a side channel
+      def message = nil
+
+      # @return [Integer] new input plus output
+      def fresh = up - cached + down
+
+      # @return [Boolean]
+      def failed? = !@error.nil?
+
+      # @return [OpenLanes::Execution::Transcript::Progress]
+      def progress = Execution::Transcript::Progress.new(activity:, up:, down:, subagents: 0, pid:, message: nil)
+
+      # @param chunk [String, nil]
+      # @return [void]
+      def push(chunk)
+        return if chunk.nil?
+
+        @buffer << chunk
+        while (index = @buffer.index("\n"))
+          consume(@buffer.slice!(0..index).chomp)
+        end
+      end
+
+      # @return [void]
+      def finish
+        consume(@buffer.slice!(0..-1).to_s)
+        @trace&.close
+        @trace = nil
+      end
+
+      private
+
+      # @param line [String]
+      # @return [void]
+      def consume(line)
+        text = line.strip
+        return if text.empty?
+
+        @trace&.write("#{text}\n")
+        @trace&.flush
+        event = text.start_with?("{") ? parse(text) : nil
+        return @plain << text if event.nil?
+
+        handle(event)
+      end
+
+      # @param text [String]
+      # @return [Hash, nil]
+      def parse(text)
+        value = JSON.parse(text)
+        value.is_a?(Hash) ? value : nil
+      rescue JSON::ParserError
+        nil
+      end
+
+      # @param event [Hash]
+      # @return [void]
+      def handle(event)
+        type = event["type"].to_s
+        meter(event)
+        @tools += 1 if type.match?(/tool|command|exec/i) && type.match?(/start|call|begin/i)
+        @error = describe_error(event) if type.match?(/error|fail/i)
+        said = text_in(event)
+        if said
+          @activity = said.lines.first.to_s.strip[0, Execution::Transcript::LIMIT]
+          @result = said
+        end
+        @on_progress&.call(progress)
+      end
+
+      # Usage counts arrive per turn, so they are added rather than replaced.
+      #
+      # @param event [Hash]
+      # @return [void]
+      def meter(event)
+        usage = find(event, "usage")
+        return unless usage.is_a?(Hash)
+
+        @up += usage["input_tokens"].to_i
+        @down += usage["output_tokens"].to_i
+        @cached += usage["cached_input_tokens"].to_i
+      end
+
+      # @param event [Hash]
+      # @return [String]
+      def describe_error(event)
+        (find(event, "message") || find(event, "error") || event["type"]).to_s
+      end
+
+      # The agent's own words, wherever this CLI put them.
+      #
+      # @param event [Hash]
+      # @return [String, nil]
+      def text_in(event)
+        text = find(event, "text")
+        text.is_a?(String) && !text.strip.empty? ? text : nil
+      end
+
+      # Depth-first search for the first value under +key+.
+      #
+      # @param node [Object]
+      # @param key [String]
+      # @return [Object, nil]
+      def find(node, key)
+        case node
+        when Hash
+          return node[key] if node.key?(key)
+
+          node.each_value do |value|
+            found = find(value, key)
+            return found unless found.nil?
+          end
+          nil
+        when Array
+          node.each do |value|
+            found = find(value, key)
+            return found unless found.nil?
+          end
+          nil
+        end
+      end
+    end
+  end
+end