space-architect 2.0.0.rc1 → 2.0.0.rc2

data/lib/space_architect/gate_lint.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "dry/validation"
+require "dry/validation/extensions/monads"
+require "dry/monads"
+
+module Space::Architect
+  # Validates the structured gates block parsed from an iteration's
+  # ## Acceptance Criteria section. Returns a Dry::Monads::Result:
+  #   Success(gates) — well-formed (or empty list)
+  #   Failure([messages]) — aggregated lint errors
+  class GateLint
+    include Dry::Monads[:result]
+
+    class GateContract < Dry::Validation::Contract
+      VALID_OPS = %w[>= <= > < == !=].freeze
+
+      json do
+        config.validate_keys = true
+
+        required(:id).filled(:string)
+        required(:ac).filled(:string)
+        required(:cmd).filled(:string)
+        optional(:cwd).maybe(:string)
+        optional(:timeout)
+        required(:expect).hash do
+          optional(:exit_code)
+          optional(:stdout_match).filled(:string)
+          optional(:threshold).hash do
+            required(:match).filled(:string)
+            required(:op).filled(:string)
+            required(:value)
+          end
+        end
+      end
+
+      rule(:cmd) { key.failure("must not be blank") if values[:cmd].is_a?(String) && values[:cmd].strip.empty? }
+      rule(:id)  { key.failure("must not be blank") if values[:id].is_a?(String) && values[:id].strip.empty? }
+      rule(:ac)  { key.failure("must not be blank") if values[:ac].is_a?(String) && values[:ac].strip.empty? }
+
+      rule(:expect) do
+        next unless values[:expect].is_a?(Hash)
+        known = %i[exit_code stdout_match threshold]
+        key.failure("must have at least one of: #{known.join(", ")}") if known.none? { |k| values[:expect].key?(k) }
+      end
+
+      rule("expect.exit_code") do
+        val = values.dig(:expect, :exit_code)
+        key.failure("must be an Integer") if !val.nil? && !val.is_a?(Integer)
+      end
+
+      rule("expect.threshold.op") do
+        val = values.dig(:expect, :threshold, :op)
+        key.failure("must be one of: #{VALID_OPS.join(", ")}") if val.is_a?(String) && !VALID_OPS.include?(val)
+      end
+
+      rule("expect.threshold.match") do
+        val = values.dig(:expect, :threshold, :match)
+        next unless val.is_a?(String)
+        begin
+          n = Regexp.new("#{val}|(?:)").match("").captures.size
+          key.failure("must contain exactly one capture group (found #{n})") unless n == 1
+        rescue RegexpError => e
+          key.failure("invalid regexp: #{e.message}")
+        end
+      end
+
+      rule("expect.threshold.value") do
+        val = values.dig(:expect, :threshold, :value)
+        key.failure("must be a Number") if !val.nil? && !val.is_a?(Numeric)
+      end
+
+      rule(:timeout) do
+        val = values[:timeout]
+        key.failure("must be a positive number of seconds") if !val.nil? && (!val.is_a?(Numeric) || val <= 0)
+      end
+    end
+
+    def self.call(gates) = new.call(gates)
+
+    def call(gates)
+      return Success([]) if gates.nil? || (gates.is_a?(Array) && gates.empty?)
+      return Failure(["gates block must be a YAML list, got #{gates.class}"]) unless gates.is_a?(Array)
+
+      errors   = []
+      seen_ids = {}
+      contract = GateContract.new
+
+      gates.each.with_index(1) do |gate, i|
+        pfx = "gate[#{i}]"
+        unless gate.is_a?(Hash)
+          errors << "#{pfx}: must be a hash, got #{gate.class}"
+          next
+        end
+
+        result = contract.call(gate)
+        flatten_errors(result.errors.to_h, pfx, errors) unless result.success?
+
+        id = gate["id"] || gate[:id]
+        id = (id.is_a?(String) && !id.strip.empty?) ? id : nil
+        next unless id
+
+        if seen_ids.key?(id)
+          errors << "#{pfx}: duplicate id '#{id}' (also at gate[#{seen_ids[id]}])"
+        else
+          seen_ids[id] = i
+        end
+      end
+
+      errors.empty? ? Success(gates) : Failure(errors)
+    end
+
+    private
+
+    # Recursively flatten the nested errors hash from dry-validation into
+    # a flat Array<String>, translating "is not allowed" into "unknown key: <name>".
+    def flatten_errors(node, prefix, acc)
+      case node
+      when Array
+        node.each do |item|
+          case item
+          when String
+            if item == "is not allowed"
+              *parent_parts, key_name = prefix.split(".")
+              acc << "#{parent_parts.join(".")}: unknown key: #{key_name}"
+            else
+              acc << "#{prefix}: #{item}"
+            end
+          when Array, Hash
+            flatten_errors(item, prefix, acc)
+          end
+        end
+      when Hash
+        node.each do |k, v|
+          flatten_errors(v, "#{prefix}.#{k}", acc)
+        end
+      end
+    end
+  end
+end

data/lib/space_architect/harness.rb

@@ -54,7 +54,9 @@ module Space::Architect
         @disallowed_tools = disallowed_tools
       end
 
-      def run(prompt_path:, run_log_path:, chdir:, push_url: nil, push_token: nil, push_client: nil)
+      TIMEOUT_EXIT_CODE = 124
+
+      def run(prompt_path:, run_log_path:, chdir:, push_url: nil, push_token: nil, push_client: nil, timeout: nil)
         prompt_path  = Pathname.new(prompt_path)
         run_log_path = Pathname.new(run_log_path)
 
@@ -65,9 +67,28 @@ module Space::Architect
               child = Async::Process::Child.new(*argv, chdir: chdir.to_s, in: prompt_io, out: w, err: log)
               w.close
               tasks = start_tee(r, log, push_url: push_url, push_token: push_token, push_client: push_client)
+              timed_out    = false
+              timeout_task = nil
+
+              # Async::Task#with_timeout cannot do TERM→grace→KILL because
+              # Async::Process::Child#wait_thread's ensure goes straight to KILL.
+              # Instead: a concurrent fiber fires after the deadline and escalates.
+              # transient: true so the reactor doesn't wait for it when main work finishes.
+              if timeout && timeout > 0
+                timeout_task = Async(transient: true) do
+                  sleep timeout
+                  timed_out = true
+                  Process.kill("TERM", -child.pid) rescue nil
+                  sleep 0.5
+                  Process.kill("KILL", -child.pid) rescue nil
+                end
+              end
+
               status = child.wait
+              timeout_task&.stop
+
               tasks.each(&:wait)
-              status.exitstatus
+              timed_out ? TIMEOUT_EXIT_CODE : status.exitstatus
             end
           end
         end
@@ -193,7 +214,7 @@ module Space::Architect
         cfg
       end
 
-      def run(prompt_path:, run_log_path:, chdir:)
+      def run(prompt_path:, run_log_path:, chdir:, timeout: nil) # timeout: deferred — opencode kill path is out of scope
         prompt_path  = Pathname.new(prompt_path)
         run_log_path = Pathname.new(run_log_path)
         config_path  = write_config

data/lib/space_architect/templates/architect.md.erb

@@ -2,11 +2,11 @@
 
 > Cross-iteration table of contents for the Architect Loop. Per-iteration detail lives in
 > architecture/I<NN>-<iteration>.md — this file only indexes the iterations and carries
-> mission-wide state. Keep it short (~150 lines): the next session must grok it
+> project-wide state. Keep it short (~150 lines): the next session must grok it
 > in under a minute. Not in the committed architecture = didn't happen.
 >
-> Durable mission contract: `architecture/BRIEF.md` (numbered §sections, cited as BRIEF §N).
-> Create it with `architect brief new`. Edits to a §section are mission-scope decisions —
+> Durable project contract: `architecture/BRIEF.md` (numbered §sections, cited as BRIEF §N).
+> Create it with `architect brief new`. Edits to a §section are project-scope decisions —
 > log them in the Decisions log below, never as silent per-iteration drift.
 
 ## TL;DR (keep current)
@@ -34,13 +34,24 @@
 
 ## Iteration index
 
-<!-- Add a row per iteration. Create iterations with `architect new <name>`. -->
+<!-- Rows are added here only for SCAFFOLDED iterations. `architect new <name>` allocates
+     the ordinal at spec-time and scaffolds architecture/I<NN>-<name>.md. Do NOT
+     pre-number planned work — un-numbered planned items live in the Backlog below. -->
 
 | I# | Iteration | Status | freeze_sha | Integration branch | Verdict | File |
 |----|-----------|--------|-----------|--------------------|---------|------|
 
 Status values: speccing → frozen → dispatched → in-flight → awaiting-verdict → done.
 
+## Backlog (ordered; no ordinal until `architect new`)
+
+<!-- Next-up first. Each item gets its ordinal only when it is about to be specced:
+     run `architect new <name>` at that point to allocate the ordinal at spec-time and
+     scaffold the iteration file. Pre-numbering planned work forces renumber churn every
+     time priorities reshuffle. -->
+
+- _[next planned item]_
+
 ## Open items for the human / architect
 
 <!-- Blocking items: unresolved disagreements (which iteration), scope questions,

data/lib/space_architect/templates/brief.md.erb

@@ -1,11 +1,11 @@
 # BRIEF — <%= @_title %>
 
-> Durable mission contract for the Architect Loop. The numbered §sections below are the
+> Durable project contract for the Architect Loop. The numbered §sections below are the
 > stable, cross-iteration address space: every iteration cites them as **BRIEF §N** in its
 > Grounds, Specification, Acceptance Criteria, and Verdict (e.g. `(BRIEF §3.1)`), the way each
-> gate addresses its intent back to one frozen reference. Frozen early; edits are mission-scope
+> gate addresses its intent back to one frozen reference. Frozen early; edits are project-scope
 > decisions logged in ARCHITECT.md's Decisions log, never silent per-iteration drift. Optional —
-> a discovery mission may defer this and cite per-iteration Grounds until the shape stabilizes,
+> a discovery project may defer this and cite per-iteration Grounds until the shape stabilizes,
 > then promote the consolidated picture here once.
 
 ## 1. Goal & non-goals
@@ -38,6 +38,6 @@ frozen proof. An iteration's Specification cites its row here (e.g. "BRIEF §5 S
 <!-- Known risks and the things a builder's PHASE 0 should challenge — cited from specs as
 "BRIEF §6". -->
 
-## 7. Definition of done (whole mission)
+## 7. Definition of done (whole project)
 
-<!-- The mission-level DoD. Iteration gates diff against "BRIEF §7 DoD". -->
+<!-- The project-level DoD. Iteration gates diff against "BRIEF §7 DoD". -->

data/lib/space_architect/templates/iteration.md.erb

@@ -32,16 +32,27 @@ Write + commit: `architect section <%= @_name %> specification --from <file>`. -
 
 ## Acceptance Criteria
 
-<!-- PROOF. Exact gate commands + thresholds. `architect freeze <%= @_name %>`
-commits this file and records its SHA as freeze_sha. Read-only afterward — any
-change to Grounds/Specification/Acceptance Criteria = automatic iteration FAIL. -->
+<!-- PROOF. Write the prose conditions of correctness (AC1, AC2, …) that the
+architect judges against. Runnable checks live in the fenced ```gates block below
+(parsed at freeze time — absent or empty is allowed; malformed fails freeze).
+`architect freeze <%= @_name %>` commits this file and records its SHA as
+freeze_sha. Read-only afterward — any change to Grounds/Specification/Acceptance
+Criteria = automatic iteration FAIL. -->
 
 > Gate-pass is necessary, not sufficient: the architect also reads the diff against the
 > cited **BRIEF §sections** intent and the §1 cardinal invariant before the verdict.
 
-| AC# | Command | Threshold | Brief § |
-|-----|---------|-----------|---------|
-|     |         |           |         |
+**AC1.** ...
+
+```gates
+# Each gate backs one prose AC above. Remove the comment markers to activate.
+# - id: suite-green        # unique slug within the iteration (required)
+#   ac: AC1                # which prose AC this gate backs (required)
+#   cwd: repos/my-repo     # run dir, relative to space root (optional; consumed by I03)
+#   cmd: bundle exec rake test  # shell command (required, non-empty)
+#   expect:                # at least one of: exit_code, stdout_match, threshold
+#     exit_code: 0
+```
 
 ## Builder Prompt
 

data/lib/space_architect.rb

@@ -6,7 +6,9 @@ require "space_src"
 require_relative "space_architect/harness"
 require_relative "space_architect/run_creator"
 require_relative "space_architect/dispatcher"
-require_relative "space_architect/architect_mission"
+require_relative "space_architect/gate_lint"
+require_relative "space_architect/gate_evaluator"
+require_relative "space_architect/architect_project"
 require_relative "space_architect/skill_installer"
 require_relative "space_architect/research"
 require_relative "space_architect/cli"

data/lib/space_core/cli/build.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../oci_packer"
+require_relative "../oci_builder"
+
+module Space::Core::CLI
+class Build < BaseCommand
+  desc "Build (and tag) the OCI image for the current space"
+
+  def call(**opts)
+    setup_terminal(**opts.slice(:color, :colors))
+    handle_errors do
+      result = store.current.bind do |space|
+        out_dir = space.path.join("build", "oci")
+        Space::Core::OciPacker.new(space: space, output_dir: out_dir).generate.bind do
+          Space::Core::OciBuilder.new(space: space, output_dir: out_dir).command
+        end
+      end
+      render(result) do |argv|
+        terminal.say "Building: #{argv.join(' ')}"
+        out.flush
+        Kernel.exec(*argv)
+      end
+    end
+  end
+end
+end

data/lib/space_core/cli/help.rb

@@ -16,7 +16,14 @@ module Space::Core::CLI
   # output stay plain. The `src` binary never loads space_core, so its own plain
   # Usage is untouched.
   module Help
-    TAGLINE = "date-prefixed workspaces; repos provisioned on fibers at copy-on-write speed"
+    # One tagline per binary — the root header is served for both `space` and
+    # `architect` from here, so we pick by $PROGRAM_NAME. The default covers the
+    # test runner and any other invocation where the binary can't be identified.
+    TAGLINES = {
+      "space"     => "date-prefixed workspaces; repos provisioned on fibers at copy-on-write speed",
+      "architect" => "the Architect Loop: structured judgment plus a fleet of headless AI builders"
+    }.freeze
+    DEFAULT_TAGLINE = TAGLINES.fetch("space")
 
     module_function
 
@@ -39,7 +46,13 @@ module Space::Core::CLI
       return unless result.names.empty?
 
       "#{pastel.bold.cyan("space-architect")} #{pastel.dim(Space::Core::VERSION)} " \
-        "#{pastel.dim("— #{TAGLINE}")}\n"
+        "#{pastel.dim("— #{tagline}")}\n"
+    end
+
+    # The tagline for the binary in hand: `space` and `architect` each get their
+    # own, keyed off $PROGRAM_NAME (the same signal program_prefix reads).
+    def tagline
+      TAGLINES.fetch(File.basename($PROGRAM_NAME), DEFAULT_TAGLINE)
     end
 
     def footer(result, pastel)

data/lib/space_core/cli/pack.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "pathname"
+require_relative "../oci_packer"
+
+module Space::Core::CLI
+class Pack < BaseCommand
+  desc "Generate a portable OCI build context for the current space"
+  option :output, aliases: ["-o"], type: :string, default: nil,
+         desc: "Output directory (default: build/oci/ under the space root)"
+
+  def call(output: nil, **opts)
+    setup_terminal(**opts.slice(:color, :colors))
+    handle_errors do
+      result = store.current.bind do |space|
+        out_dir = output ? Pathname.new(output).expand_path : space.path.join("build", "oci")
+        Space::Core::OciPacker.new(space: space, output_dir: out_dir).generate
+          .fmap { |dir| { space: space, dir: dir } }
+      end
+      render(result) do |r|
+        terminal.success "Generated OCI context: #{r[:dir]}"
+        terminal.say "Build: docker build -f #{r[:dir]}/Dockerfile -t #{r[:space].id}:latest ."
+        terminal.say "  (run from: #{r[:space].path})"
+        CLI.record_outcome(Outcome.new(exit_code: 0))
+      end
+    end
+  end
+end
+end

data/lib/space_core/cli/repo.rb

@@ -3,7 +3,7 @@
 module Space::Core::CLI
 module Repo
   class Add < BaseCommand
-    desc "Clone repos into the current space"
+    desc "Add repos to the current space (copy-on-write from an evergreen checkout when available, else clone)"
     argument :repos, type: :array, required: false, desc: "REPO [REPO...]"
 
     def call(repos: [], **opts)

data/lib/space_core/cli/run.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "../oci_runner"
+
+module Space::Core::CLI
+class Run < BaseCommand
+  desc "Run the packed OCI image for the current space (auth injected at runtime)"
+
+  argument :command, type: :array, required: false, desc: "Command to run in the container (default: login shell)"
+  option :tty, type: :boolean, default: nil, desc: "Force interactive TTY (default: auto-detect)"
+
+  def call(command: [], tty: nil, **opts)
+    setup_terminal(**opts.slice(:color, :colors))
+    handle_errors do
+      result = store.current.bind do |space|
+        runner = Space::Core::OciRunner.new(space: space, interactive: tty.nil? ? CLI.tty?(out) : tty)
+        runner.command(command).fmap { |argv| { argv: argv, runner: runner } }
+      end
+      render(result) do |r|
+        r[:runner].host_dirs.each { |d| FileUtils.mkdir_p(d) }
+        terminal.say "Running: #{r[:argv].join(' ')}"
+        out.flush # Kernel.exec replaces the process without flushing buffered IO
+        Kernel.exec(*r[:argv])
+      end
+    end
+  end
+end
+end

data/lib/space_core/cli.rb

@@ -137,6 +137,9 @@ require_relative "cli/status"
 require_relative "cli/config"
 require_relative "cli/repo"
 require_relative "cli/shell"
+require_relative "cli/pack"
+require_relative "cli/build"
+require_relative "cli/run"
 
 Space::Core::CLI::Registry.register "init",    Space::Core::CLI::Init
 Space::Core::CLI::Registry.register "new",     Space::Core::CLI::New
@@ -169,3 +172,6 @@ Space::Core::CLI::Registry.register "shell" do |s|
   s.register "fish",     Space::Core::CLI::Shell::Fish
   s.register "complete", Space::Core::CLI::Shell::Complete
 end
+Space::Core::CLI::Registry.register "pack",  Space::Core::CLI::Pack
+Space::Core::CLI::Registry.register "build", Space::Core::CLI::Build
+Space::Core::CLI::Registry.register "run",   Space::Core::CLI::Run

data/lib/space_core/oci_builder.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "open3"
+require "pathname"
+require "dry/monads"
+
+module Space::Core
+  class OciBuilder
+    include Dry::Monads[:result]
+
+    def initialize(space:, output_dir:)
+      @space = space
+      @output_dir = Pathname.new(output_dir)
+    end
+
+    def version
+      compute_version.value!
+    end
+
+    def image
+      "#{space.id}:#{version}"
+    end
+
+    def latest
+      "#{space.id}:latest"
+    end
+
+    def command
+      compute_version.fmap do |ver|
+        [
+          "container", "build",
+          "-f", @output_dir.join("Dockerfile").to_s,
+          "-t", "#{space.id}:#{ver}",
+          "-t", latest,
+          space.path.to_s
+        ]
+      end
+    end
+
+    private
+
+    attr_reader :space
+
+    def compute_version
+      sha_out, _, sha_status = Open3.capture3("git", "-C", space.path.to_s, "rev-parse", "--short=12", "HEAD")
+      unless sha_status.success?
+        return Failure("space is not a git repository with a commit; cannot compute a version tag")
+      end
+
+      sha = sha_out.strip
+      status_out, _, _ = Open3.capture3("git", "-C", space.path.to_s, "status", "--porcelain")
+      dirty = !status_out.strip.empty?
+      Success(dirty ? "#{sha}-dirty" : sha)
+    end
+  end
+end

data/lib/space_core/oci_packer.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "erb"
+require "fileutils"
+require "pathname"
+require "dry/monads"
+
+module Space::Core
+  class OciPacker
+    include Dry::Monads[:result]
+
+    TEMPLATE_DIR = Pathname.new(__dir__).join("templates", "oci").freeze
+
+    def initialize(space:, output_dir:)
+      @space = space
+      @output_dir = Pathname.new(output_dir)
+    end
+
+    def generate
+      FileUtils.mkdir_p(@output_dir)
+      validated = validate_provision_scripts(space.provision_scripts)
+      return validated if validated.failure?
+      validated = validate_persist_paths(space.persist_paths)
+      return validated if validated.failure?
+      write("Dockerfile",    render_template("dockerfile.erb"))
+      write("entrypoint.sh", entrypoint_content, mode: 0o755)
+      write("Dockerfile.dockerignore", render_template("dockerignore.erb"))
+      Success(@output_dir)
+    rescue StandardError => e
+      Failure(e)
+    end
+
+    private
+
+    attr_reader :space, :output_dir
+
+    def space_id
+      @space.id
+    end
+
+    def repos
+      @space.repos
+    end
+
+    def provision_scripts
+      @space.provision_scripts
+    end
+
+    def persist_paths
+      @space.persist_paths
+    end
+
+    def validate_provision_scripts(scripts)
+      scripts.each do |rel_path|
+        if Pathname.new(rel_path).absolute?
+          return Failure("provision script '#{rel_path}' must not be an absolute path")
+        end
+
+        resolved = space.path.join(rel_path).cleanpath
+        space_root = space.path.cleanpath
+        unless resolved.to_s.start_with?("#{space_root}/") || resolved == space_root
+          return Failure("provision script '#{rel_path}' escapes the space root")
+        end
+
+        return Failure("provision script '#{rel_path}' does not exist under the space root") unless resolved.exist?
+      end
+      Success(scripts)
+    end
+
+    def validate_persist_paths(paths)
+      paths.each do |path|
+        unless Pathname.new(path).absolute?
+          return Failure("persist path '#{path}' must be an absolute path")
+        end
+      end
+      Success(paths)
+    end
+
+    def entrypoint_content
+      @entrypoint_content ||= render_template("entrypoint.sh.erb")
+    end
+
+    def entrypoint_b64
+      [entrypoint_content].pack("m0")
+    end
+
+    def render_template(name)
+      template_path = TEMPLATE_DIR.join(name)
+      ERB.new(template_path.read, trim_mode: "-").result(binding)
+    end
+
+    def write(filename, content, mode: 0o644)
+      path = @output_dir.join(filename)
+      File.write(path, content)
+      File.chmod(mode, path)
+      path
+    end
+  end
+end

data/lib/space_core/oci_runner.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "dry/monads"
+
+module Space::Core
+  class OciRunner
+    include Dry::Monads[:result]
+
+    AUTH_ENV = %w[ANTHROPIC_API_KEY CLAUDE_CODE_OAUTH_TOKEN ANTHROPIC_BASE_URL].freeze
+
+    def initialize(space:, env: ENV.to_h, interactive: true)
+      @space = space
+      @env = env
+      @interactive = interactive
+    end
+
+    def image
+      "#{space.id}:latest"
+    end
+
+    def mounts
+      space.persist_paths.map do |guest|
+        [space.path.join(".state" + guest), guest]
+      end
+    end
+
+    def host_dirs
+      mounts.map(&:first)
+    end
+
+    def command(extra = [])
+      validated = validate_persist_paths(space.persist_paths)
+      return validated if validated.failure?
+
+      argv = [
+        "container", "run", "--rm",
+        *(@interactive ? ["-i", "-t"] : []),
+        *auth_flags,
+        *mount_flags,
+        image,
+        *extra
+      ]
+      Success(argv)
+    end
+
+    private
+
+    attr_reader :space, :env, :interactive
+
+    def auth_flags
+      AUTH_ENV.each_with_object([]) do |var, flags|
+        val = env[var]
+        flags.push("-e", var) if val && !val.empty?
+      end
+    end
+
+    def mount_flags
+      mounts.each_with_object([]) do |(host, guest), flags|
+        flags.push("-v", "#{host}:#{guest}")
+      end
+    end
+
+    def validate_persist_paths(paths)
+      paths.each do |path|
+        unless Pathname.new(path).absolute?
+          return Failure("persist path '#{path}' must be an absolute path")
+        end
+      end
+      Success(paths)
+    end
+  end
+end