space-architect 1.3.0 → 2.0.0.rc2

data/lib/space_architect/cli/research.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Space::Architect
+  module CLI
+    module Architect
+      module Research
+        class Dispatch < BaseCommand
+          desc "Dispatch detached read-only research lanes (one per prompt file)"
+          argument :prompts, required: true,
+                             desc: "Prompt file(s) to dispatch (space-separated paths)"
+          option :model,     default: nil, desc: "Researcher model override (default: the reference default claude-sonnet-4-6)"
+          option :max_turns, default: "40", desc: "Max turns per researcher"
+
+          def call(prompts:, model: nil, max_turns: "40", **opts)
+            setup_terminal(**opts.slice(:color, :colors))
+            handle_errors do
+              render(store.find(opts[:space])) do |sp|
+                paths = Array(prompts)
+                supervisor = Space::Architect::Research::Supervisor.new(space: sp)
+                kwargs = { max_turns: max_turns.to_i }
+                kwargs[:model] = model if model
+                runs = supervisor.dispatch(paths, **kwargs)
+                runs.each do |run|
+                  terminal.say "dispatched #{run.id} (pid #{run.pid}) → #{terminal.path(run.run_log_path)}"
+                end
+                CLI.record_outcome(Outcome.new(exit_code: 0))
+              end
+            end
+          end
+        end
+
+        class Status < BaseCommand
+          desc "Show status of dispatched research runs"
+          argument :space, required: false, desc: "Space identifier (default: $PWD)"
+
+          def call(space: nil, **opts)
+            setup_terminal(**opts.slice(:color, :colors))
+            handle_errors do
+              render(store.find(space)) do |sp|
+                supervisor = Space::Architect::Research::Supervisor.new(space: sp)
+                entries = supervisor.status
+                if entries.empty?
+                  terminal.say "No research runs registered"
+                else
+                  rows = entries.map do |e|
+                    run = e[:run]
+                    [run.id, run.pid.to_s, e[:state].to_s, run.model, e[:tail].last.to_s.slice(0, 60)]
+                  end
+                  terminal.say terminal.table(%w[ID PID State Model LastLine], rows)
+                end
+                CLI.record_outcome(Outcome.new(exit_code: 0))
+              end
+            end
+          end
+        end
+
+        class Wait < BaseCommand
+          desc "Wait for all dispatched research runs to complete"
+          argument :space,    required: false, desc: "Space identifier (default: $PWD)"
+          option   :quiet,    type: :boolean, default: false,
+                              desc: "L0: suppress all output; exit status only"
+          option   :level,    type: :integer, default: 1,
+                              desc: "Verbosity level: 1=lifecycle 2=+text 3=+tools 4=+io"
+          option   :thinking, type: :boolean, default: false,
+                              desc: "Show assistant thinking blocks"
+          option   :jsonl,    type: :boolean, default: false,
+                              desc: "Emit raw lane-tagged JSONL (mutually exclusive with level/quiet)"
+
+          def call(space: nil, quiet: false, level: 1, thinking: false, jsonl: false, **opts)
+            setup_terminal(**opts.slice(:color, :colors))
+            handle_errors do
+              render(store.find(space)) do |sp|
+                supervisor = Space::Architect::Research::Supervisor.new(space: sp)
+                result = supervisor.wait(
+                  quiet:   quiet,
+                  level:   level.to_i,
+                  thinking: thinking,
+                  jsonl:   jsonl
+                )
+                CLI.record_outcome(Outcome.new(exit_code: result == :ok ? 0 : 1))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Space::Architect::CLI::Registry.register "research" do |r|
+  r.register "dispatch", Space::Architect::CLI::Architect::Research::Dispatch
+  r.register "status",   Space::Architect::CLI::Architect::Research::Status
+  r.register "wait",     Space::Architect::CLI::Architect::Research::Wait
+end

data/lib/space_architect/cli/space.rb

@@ -1,35 +1,29 @@
 # frozen_string_literal: true
 
-SpaceArchitect::CLI::Registry.register "space" do |prefix|
-  prefix.register "init",    SpaceArchitect::CLI::Init
-  prefix.register "new",     SpaceArchitect::CLI::New
-  prefix.register "list",    SpaceArchitect::CLI::List
-  prefix.register "ls",      SpaceArchitect::CLI::List
-  prefix.register "show",    SpaceArchitect::CLI::Show
-  prefix.register "path",    SpaceArchitect::CLI::Path
-  prefix.register "use",     SpaceArchitect::CLI::Use
-  prefix.register "current", SpaceArchitect::CLI::Current
-  prefix.register "status",  SpaceArchitect::CLI::Status
-  prefix.register "config" do |c|
-    c.register "show", SpaceArchitect::CLI::Config::Show
-    c.register "path", SpaceArchitect::CLI::Config::ConfigPath
-    c.register "set",  SpaceArchitect::CLI::Config::Set
-  end
-  prefix.register "repo" do |r|
-    r.register "add",     SpaceArchitect::CLI::Repo::Add
-    r.register "list",    SpaceArchitect::CLI::Repo::RepoList
-    r.register "ls",      SpaceArchitect::CLI::Repo::RepoList
-    r.register "resolve", SpaceArchitect::CLI::Repo::Resolve
-  end
-  prefix.register "repos" do |r|
-    r.register "add",     SpaceArchitect::CLI::Repo::Add
-    r.register "list",    SpaceArchitect::CLI::Repo::RepoList
-    r.register "ls",      SpaceArchitect::CLI::Repo::RepoList
-    r.register "resolve", SpaceArchitect::CLI::Repo::Resolve
-  end
-  prefix.register "shell" do |s|
-    s.register "init",     SpaceArchitect::CLI::Shell::ShellInit
-    s.register "fish",     SpaceArchitect::CLI::Shell::Fish
-    s.register "complete", SpaceArchitect::CLI::Shell::Complete
+require "space_core/cli"
+
+module Space::Architect
+  module CLI
+    # Exit-code bridge to the Space::Core CLI engine.
+    # `architect space <args>` (and `exe/space <args>` via Space::Core::CLI directly)
+    # hands the raw remainder to Space::Core's own dry-cli registry and translates
+    # Space::Core's recorded Outcome into the host exit code.
+    # Space::Core has its own Registry, Outcome, and :space_core_cli_outcome thread-local;
+    # this is the seam between the two registries (NOT a re-registration).
+    def self.dispatch_space(rest, out = $stdout, err = $stderr)
+      if ::Space::Core::CLI::TOP_LEVEL_HELP.include?(rest)
+        out.puts Dry::CLI::Usage.call(::Space::Core::CLI::Registry.get([]))
+        return 0
+      end
+
+      if ::Space::Core::CLI::VERSION_REQUEST.include?(rest)
+        out.puts ::Space::Core::VERSION
+        return 0
+      end
+
+      Thread.current[:space_core_cli_outcome] = nil
+      Dry::CLI.new(::Space::Core::CLI::Registry).call(arguments: rest, out: out, err: err)
+      ::Space::Core::CLI.last_outcome&.exit_code || 0
+    end
   end
 end

data/lib/space_architect/cli/src.rb

@@ -1,32 +1,38 @@
 # frozen_string_literal: true
 
-require "space_architect/pristine/cli"
+require "space_src/cli"
 
-module SpaceArchitect
+module Space::Architect
   module CLI
-    # Exit-code bridge to the vendored Pristine (repo-tender) CLI engine.
-    # `architect src <args>` hands the raw remainder to Pristine's own dry-cli
-    # registry and translates Pristine's recorded Outcome into the host exit code.
-    # Pristine has its own Registry, Outcome, and :repo_tender_cli_* thread-locals;
-    # this is the seam between the two registries (NOT a re-registration). Pristine's
+    # Exit-code bridge to the Space::Src CLI engine.
+    # `architect src <args>` hands the raw remainder to Space::Src's own dry-cli
+    # registry and translates Space::Src's recorded Outcome into the host exit code.
+    # Space::Src has its own Registry, Outcome, and :space_src_cli_* thread-locals;
+    # this is the seam between the two registries (NOT a re-registration). Space::Src's
     # top-level help/version interceptors call Kernel.exit, so we reproduce that
     # interception here against the injected IO instead of delegating to them.
     # dry-cli's internal exit on a bare group / unknown command propagates as
     # SystemExit — same as the host's own bare groups (e.g. `space repo`) — and is
     # intentionally NOT rescued (accepted behavior change).
     def self.dispatch_src(rest, out = $stdout, err = $stderr)
-      if Pristine::CLI::TOP_LEVEL_HELP.include?(rest)
-        out.puts Dry::CLI::Usage.call(Pristine::CLI::Registry.get([]))
+      if ::Space::Src::CLI::TOP_LEVEL_HELP.include?(rest)
+        out.puts Dry::CLI::Usage.call(::Space::Src::CLI::Registry.get([]))
         return 0
       end
-      if Pristine::CLI::VERSION_REQUEST.include?(rest)
-        out.puts SpaceArchitect::Pristine::VERSION
+      if ::Space::Src::CLI::VERSION_REQUEST.include?(rest)
+        out.puts ::Space::Src::VERSION
         return 0
       end
 
-      Thread.current[:repo_tender_cli_outcome] = nil
-      Dry::CLI.new(Pristine::CLI::Registry).call(arguments: rest, out: out, err: err)
-      Pristine::CLI.last_outcome&.exit_code || 0
+      if ::Space::Src::CLI.bare_query?(rest)
+        paths = ::Space::Src::CLI.make_paths
+        config = ::Space::Src::Config::Store.load(paths.config_file).success
+        return ::Space::Src::Nav.dispatch(rest[0], out, err, config.base_dir)
+      end
+
+      Thread.current[:space_src_cli_outcome] = nil
+      Dry::CLI.new(::Space::Src::CLI::Registry).call(arguments: rest, out: out, err: err)
+      ::Space::Src::CLI.last_outcome&.exit_code || 0
     end
   end
 end

data/lib/space_architect/cli.rb

@@ -1,15 +1,20 @@
 # frozen_string_literal: true
 
 require "dry/cli"
+require "pastel"
+require "space_core/cli"
 
-module SpaceArchitect
+module Space::Architect
   module CLI
-    Outcome = Data.define(:exit_code, :message) do
-      def initialize(exit_code:, message: nil) = super
-    end
+    # Delegate the outcome seam to Space::Core::CLI so both architect commands
+    # (which call CLI.record_outcome lexically) and the moved Helpers (which call
+    # CLI.record_outcome with Space::Core::CLI as lexical root) share one slot.
+    Outcome     = Space::Core::CLI::Outcome
+    Helpers     = Space::Core::CLI::Helpers
+    BaseCommand = Space::Core::CLI::BaseCommand
 
-    def self.record_outcome(o) = (Thread.current[:space_architect_outcome] = o)
-    def self.last_outcome = Thread.current[:space_architect_outcome]
+    def self.record_outcome(o) = Space::Core::CLI.record_outcome(o)
+    def self.last_outcome      = Space::Core::CLI.last_outcome
 
     module Registry
       extend Dry::CLI::Registry
@@ -19,7 +24,8 @@ module SpaceArchitect
     VERSION_REQUEST   = [["version"], ["--version"]].freeze
 
     def self.call(argv, out = $stdout, err = $stderr)
-      Thread.current[:space_architect_outcome] = nil
+      Thread.current[:space_core_cli_outcome] = nil
+      Space::Core::CLI.help_pastel = Pastel.new(enabled: Space::Core::CLI.help_colors?(argv, out, err))
 
       if TOP_LEVEL_HELP.include?(argv)
         out.puts Dry::CLI::Usage.call(Registry.get([]))
@@ -27,7 +33,7 @@ module SpaceArchitect
       end
 
       if VERSION_REQUEST.include?(argv)
-        out.puts SpaceArchitect::VERSION
+        out.puts Space::Core::VERSION
         return 0
       end
 
@@ -35,7 +41,13 @@ module SpaceArchitect
         return dispatch_src(argv[1..], out, err)
       end
 
-      Dry::CLI.new(Registry).call(arguments: normalize_args(argv), out: out, err: err)
+      normalized = normalize_args(argv)
+
+      if normalized.first == "space"
+        return dispatch_space(normalized[1..], out, err)
+      end
+
+      Dry::CLI.new(Registry).call(arguments: normalized, out: out, err: err)
       last_outcome&.exit_code || 0
     end
 
@@ -84,19 +96,7 @@ module SpaceArchitect
   end
 end
 
-require_relative "cli/options"
-require_relative "cli/helpers"
-require_relative "cli/init"
-require_relative "cli/new"
-require_relative "cli/list"
-require_relative "cli/show"
-require_relative "cli/path"
-require_relative "cli/use"
-require_relative "cli/current"
-require_relative "cli/status"
-require_relative "cli/config"
-require_relative "cli/repo"
-require_relative "cli/shell"
 require_relative "cli/architect"
 require_relative "cli/space"
 require_relative "cli/src"
+require_relative "cli/research"

data/lib/space_architect/dispatcher.rb

@@ -2,7 +2,7 @@
 
 require_relative "harness"
 
-module SpaceArchitect
+module Space::Architect
   # Thin backward-compat wrapper around Harness::ClaudeCodeHarness.
   # Existing callers that construct Dispatcher.new(...).run(...) continue to work byte-for-byte.
   class Dispatcher
@@ -17,5 +17,9 @@ module SpaceArchitect
     def run(prompt_path:, run_log_path:, chdir:)
       @harness.run(prompt_path: prompt_path, run_log_path: run_log_path, chdir: chdir)
     end
+
+    def run_detached(prompt_path:, run_log_path:, chdir:)
+      @harness.run_detached(prompt_path: prompt_path, run_log_path: run_log_path, chdir: chdir)
+    end
   end
 end

data/lib/space_architect/gate_evaluator.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Space::Architect
+  # Evaluates a single gate's captured output against its frozen expect block.
+  # Pure — no I/O. Mirrors GateLint's class shape.
+  #
+  # GateEvaluator.call(stdout:, exit_code:, expect:) → Result
+  #   result.pass?  → Boolean
+  #   result.reason → String (empty on pass, first failing matcher on fail)
+  class GateEvaluator
+    Result = Data.define(:pass, :reason) do
+      def pass? = pass
+    end
+
+    def self.call(stdout:, exit_code:, expect:) = new.call(stdout: stdout, exit_code: exit_code, expect: expect)
+
+    def call(stdout:, exit_code:, expect:)
+      e = (expect || {}).transform_keys(&:to_s)
+
+      if e.key?("exit_code")
+        expected = e["exit_code"]
+        unless exit_code == expected
+          return Result.new(pass: false, reason: "exit_code #{exit_code.inspect} != #{expected}")
+        end
+      end
+
+      if (pattern = e["stdout_match"])
+        unless Regexp.new(pattern).match?(stdout.to_s)
+          return Result.new(pass: false, reason: "stdout did not match /#{pattern}/")
+        end
+      end
+
+      if (thresh = e["threshold"])
+        result = check_threshold(stdout.to_s, thresh.transform_keys(&:to_s))
+        return result unless result.pass?
+      end
+
+      Result.new(pass: true, reason: "")
+    end
+
+    private
+
+    def check_threshold(stdout, thresh)
+      re = Regexp.new(thresh["match"])
+      m  = nil
+      stdout.scan(re) { m = Regexp.last_match }
+      return Result.new(pass: false, reason: "metric not found") unless m
+
+      captured = m.captures.first
+      begin
+        num = Float(captured)
+      rescue ArgumentError
+        return Result.new(pass: false, reason: "metric capture #{captured.inspect} is not numeric")
+      end
+
+      op    = thresh["op"]
+      value = thresh["value"]
+      unless num.public_send(op, value)
+        return Result.new(pass: false, reason: "threshold: #{num} #{op} #{value} is false")
+      end
+
+      Result.new(pass: true, reason: "")
+    end
+  end
+end

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