space-architect 1.3.0 → 2.0.0.rc2

data/lib/space_architect/harness.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
 require "async/process"
+require "async/http/client"
+require "async/http/endpoint"
+require "protocol/http/body/writable"
 require "json"
 require "pathname"
+require "uri"
 
-module SpaceArchitect
+module Space::Architect
   module Harness
     CLAUDE_DEFAULT_MODEL = "claude-sonnet-4-6"
 
@@ -14,22 +18,22 @@ module SpaceArchitect
       case name.to_s
       when "claude-code"
         if effort
-          raise Error,
+          raise Space::Core::Error,
             "effort is opencode-only (sets opencode reasoningEffort) — " \
             "claude-code effort is set via the prompt"
         end
         ClaudeCodeHarness.new(model: model, max_turns: max_turns, bin: bin)
       when "opencode"
         if model == CLAUDE_DEFAULT_MODEL
-          raise Error,
+          raise Space::Core::Error,
             "Pass --model when using --harness opencode (the claude-sonnet-4-6 default " \
             "is a Claude model ID and will not work with opencode — " \
             "try e.g. fireworks-ai/accounts/fireworks/models/glm-5p2)"
         end
-        raise Error, "config_dir is required for opencode harness" unless config_dir
+        raise Space::Core::Error, "config_dir is required for opencode harness" unless config_dir
         OpenCodeHarness.new(model: model, max_turns: max_turns, bin: bin, config_dir: config_dir, effort: effort)
       else
-        raise Error, "Unknown harness '#{name}' — valid values: claude-code, opencode"
+        raise Space::Core::Error, "Unknown harness '#{name}' — valid values: claude-code, opencode"
       end
     end
 
@@ -41,39 +45,140 @@ module SpaceArchitect
         "Bash(git branch:*)"
       ].join(",")
 
-      def initialize(model:, max_turns:, bin: nil)
-        @model     = model
-        @max_turns = max_turns
-        @bin       = bin || ENV.fetch("ARCHITECT_CLAUDE_BIN", "claude")
+      def initialize(model:, max_turns:, bin: nil,
+                     allowed_tools: ALLOWED_TOOLS, disallowed_tools: DISALLOWED_TOOLS)
+        @model            = model
+        @max_turns        = max_turns
+        @bin              = bin || ENV.fetch("ARCHITECT_CLAUDE_BIN", "claude")
+        @allowed_tools    = allowed_tools
+        @disallowed_tools = disallowed_tools
       end
 
-      def run(prompt_path:, run_log_path:, chdir:)
+      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)
 
         File.open(prompt_path, "r") do |prompt_io|
           File.open(run_log_path, "w") do |log|
-            status = Sync do
-              Async::Process.spawn(*argv, chdir: chdir.to_s, in: prompt_io, out: log, err: log)
+            r, w = IO.pipe
+            Sync do
+              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)
+              timed_out ? TIMEOUT_EXIT_CODE : status.exitstatus
             end
-            status.exitstatus
           end
         end
       end
 
+      def run_detached(prompt_path:, run_log_path:, chdir:)
+        prompt_path  = Pathname.new(prompt_path)
+        run_log_path = Pathname.new(run_log_path)
+
+        prompt_io = File.open(prompt_path, "r")
+        log       = File.open(run_log_path, "w")
+        begin
+          pid = Process.spawn(*argv, chdir: chdir.to_s, pgroup: true,
+                              in: prompt_io, out: log, err: log)
+          Process.detach(pid)
+        ensure
+          prompt_io.close
+          log.close
+        end
+        pid
+      end
+
       private
 
       def argv
-        [
+        args = [
           @bin, "-p",
           "--model", @model,
           "--permission-mode", "acceptEdits",
-          "--allowedTools", ALLOWED_TOOLS,
-          "--disallowedTools", DISALLOWED_TOOLS,
+          "--allowedTools", @allowed_tools,
           "--output-format", "stream-json",
           "--verbose",
+          "--include-partial-messages",
           "--max-turns", @max_turns.to_s
         ]
+        args += ["--disallowedTools", @disallowed_tools] unless @disallowed_tools.to_s.empty?
+        args
+      end
+
+      def start_tee(r, log, push_url:, push_token:, push_client:)
+        if push_url || push_client
+          body = Protocol::HTTP::Body::Writable.new(queue: Thread::SizedQueue.new(32))
+          push = Async { push_body(body, push_url: push_url, push_token: push_token, push_client: push_client) }
+          [Async { tee_pipe(r, log, body) }, push]
+        else
+          [Async { drain_pipe(r, log) }]
+        end
+      end
+
+      def push_body(body, push_url:, push_token:, push_client:)
+        path    = push_url ? URI.parse(push_url).path : "/"
+        headers = [["content-type", "application/x-ndjson"]]
+        headers << ["authorization", "Bearer #{push_token}"] if push_token
+        if push_client
+          push_client.post(path, headers: headers, body: body).discard
+        else
+          Async::HTTP::Client.open(Async::HTTP::Endpoint.parse(push_url)) do |c|
+            c.post(path, headers: headers, body: body).discard
+          end
+        end
+      rescue StandardError => e
+        $stderr.puts "push_body: transport error (best-effort, run log intact): #{e.class}: #{e.message}"
+      end
+
+      def tee_pipe(r, log, body)
+        pushing = true
+        while (chunk = r.gets)
+          log.write(chunk)
+          log.flush
+          if pushing
+            begin
+              body.write(chunk)
+            rescue StandardError => e
+              $stderr.puts "tee_pipe: push write failed (best-effort, continuing log): #{e.class}: #{e.message}"
+              pushing = false
+            end
+          end
+        end
+      ensure
+        body.close_write
+        r.close
+      end
+
+      def drain_pipe(r, log)
+        while (chunk = r.gets)
+          log.write(chunk)
+          log.flush
+        end
+      ensure
+        r.close
       end
     end
 
@@ -109,7 +214,7 @@ module SpaceArchitect
         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
@@ -130,6 +235,29 @@ module SpaceArchitect
         end
       end
 
+      def run_detached(prompt_path:, run_log_path:, chdir:)
+        prompt_path  = Pathname.new(prompt_path)
+        run_log_path = Pathname.new(run_log_path)
+        config_path  = write_config
+
+        env = {
+          "OPENCODE_CONFIG"                 => config_path.to_s,
+          "OPENCODE_DISABLE_PROJECT_CONFIG" => "1"
+        }
+
+        prompt_io = File.open(prompt_path, "r")
+        log       = File.open(run_log_path, "w")
+        begin
+          pid = Process.spawn(env, *argv(chdir), chdir: chdir.to_s, pgroup: true,
+                              in: prompt_io, out: log, err: log)
+          Process.detach(pid)
+        ensure
+          prompt_io.close
+          log.close
+        end
+        pid
+      end
+
       private
 
       def reasoning_provider_config

data/lib/space_architect/research/mux.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Space::Architect
+  module Research
+    # Async multiplexer: one fiber per in-flight run, each tailing its run.jsonl.
+    # Uses socketry/async fibers — NEVER threads.
+    class Mux
+      POLL_INTERVAL    = 0.15  # seconds between read attempts
+      HEARTBEAT_EVERY  = 30    # seconds of silence before heartbeat
+      FILE_WAIT_LIMIT  = 10    # seconds to wait for run.jsonl to appear
+
+      def initialize(runs, renderer:, out: $stdout)
+        @runs     = runs
+        @renderer = renderer
+        @out      = out
+      end
+
+      # Returns :ok or :failed
+      def run
+        results = Sync do
+          tasks = @runs.map do |run|
+            Async { tail_run(run) }
+          end
+          tasks.map(&:wait)
+        end
+
+        results.all? { |r| r == :ok } ? :ok : :failed
+      end
+
+      private
+
+      def tail_run(run)
+        wait_for_file(run)
+
+        unless File.exist?(run.run_log_path.to_s)
+          emit(@renderer.render(lane: run.id, events: [error_event("run.jsonl never appeared")], alive: false))
+          return :failed
+        end
+
+        emit(@renderer.render(lane: run.id, events: [], alive: true))
+
+        events_all = []
+        last_emit  = Time.now
+        terminal   = nil
+
+        File.open(run.run_log_path.to_s, "r") do |f|
+          loop do
+            line = f.gets
+            if line && !line.strip.empty?
+              ev = begin; JSON.parse(line.chomp); rescue JSON::ParserError; nil; end
+              next unless ev
+
+              events_all << ev
+              terminal = ev if ev["type"] == "result"
+
+              new_events = [ev]
+              rendered = @renderer.render(lane: run.id, events: new_events, alive: terminal.nil?)
+              emit(rendered) unless rendered.empty?
+              last_emit = Time.now
+
+              break if terminal
+            else
+              # EOF — check liveness
+              pid_alive = begin; Process.kill(0, run.pid); true; rescue Errno::ESRCH, Errno::EPERM; false; end
+
+              unless pid_alive
+                # PID dead and no terminal event → treat as failure
+                unless terminal
+                  emit(@renderer.render(lane: run.id,
+                                        events: [error_event("process died without result event")],
+                                        alive: false))
+                  return :failed
+                end
+                break
+              end
+
+              if Time.now - last_emit > HEARTBEAT_EVERY
+                emit("[#{run.id}] ⏳ still running…\n") if @renderer.lifecycle?
+                last_emit = Time.now
+              end
+
+              sleep POLL_INTERVAL
+            end
+          end
+        end
+
+        if terminal
+          extract_report(run, terminal)
+          rendered = @renderer.render(lane: run.id, events: [terminal], alive: false)
+          emit(rendered) unless rendered.empty?
+          terminal["is_error"] ? :failed : :ok
+        else
+          :failed
+        end
+      end
+
+      def wait_for_file(run)
+        deadline = Time.now + FILE_WAIT_LIMIT
+        until File.exist?(run.run_log_path.to_s) || Time.now > deadline
+          pid_alive = begin; Process.kill(0, run.pid); true; rescue Errno::ESRCH, Errno::EPERM; false; end
+          break unless pid_alive
+          sleep 0.05
+        end
+      end
+
+      def extract_report(run, terminal_ev)
+        result = terminal_ev["result"].to_s
+        return if result.empty?
+
+        Pathname.new(run.report_path).write(result)
+      end
+
+      def error_event(msg)
+        { "type" => "result", "subtype" => "error", "is_error" => true,
+          "duration_ms" => 0, "num_turns" => 0, "result" => msg }
+      end
+
+      def emit(text)
+        return if text.nil? || text.empty?
+        @out.print(text)
+        @out.flush if @out.respond_to?(:flush)
+      end
+    end
+  end
+end

data/lib/space_architect/research/registry.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+
+module Space::Architect
+  module Research
+    class Registry
+      def initialize(path)
+        @path = Pathname.new(path)
+      end
+
+      def add(run)
+        runs = load_runs
+        runs.reject! { |r| r["id"] == run.id }
+        runs << serialize(run)
+        write(runs)
+        run
+      end
+
+      def all
+        load_runs.map { |h| deserialize(h) }
+      end
+
+      def find(id)
+        load_runs.find { |h| h["id"] == id }.then { |h| h ? deserialize(h) : nil }
+      end
+
+      private
+
+      def load_runs
+        return [] unless @path.exist?
+        YAML.safe_load(@path.read, aliases: false) || []
+      end
+
+      def write(runs)
+        @path.parent.mkpath
+        @path.write(YAML.dump(runs))
+      end
+
+      def serialize(run)
+        {
+          "id"            => run.id,
+          "topic"         => run.topic,
+          "pid"           => run.pid,
+          "dir"           => run.dir.to_s,
+          "prompt_path"   => run.prompt_path.to_s,
+          "run_log_path"  => run.run_log_path.to_s,
+          "report_path"   => run.report_path.to_s,
+          "model"         => run.model,
+          "dispatched_at" => run.dispatched_at.iso8601
+        }
+      end
+
+      def deserialize(h)
+        Run.new(
+          id:            h["id"],
+          topic:         h["topic"],
+          pid:           h["pid"].to_i,
+          dir:           Pathname.new(h["dir"]),
+          prompt_path:   Pathname.new(h["prompt_path"]),
+          run_log_path:  Pathname.new(h["run_log_path"]),
+          report_path:   Pathname.new(h["report_path"]),
+          model:         h["model"],
+          dispatched_at: Time.parse(h["dispatched_at"].to_s)
+        )
+      end
+    end
+  end
+end

data/lib/space_architect/research/renderer.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Space::Architect
+  module Research
+    # Pure, testable verbosity-gated renderer for stream-json events.
+    #
+    # Levels (§5.3 ladder):
+    #   0 (quiet)  — nothing
+    #   1 (default) — lifecycle + terminal line only
+    #   2 (-v)     — + assistant text
+    #   3 (-vv)    — + tool-call names
+    #   4 (-vvv)   — + tool-call inputs and results
+    #
+    # --thinking: + assistant thinking blocks (any level > 0)
+    # --jsonl:    emit raw lane-tagged jsonl instead of human text
+    class Renderer
+      def initialize(level:, thinking: false, jsonl: false)
+        @level    = level
+        @thinking = thinking
+        @jsonl    = jsonl
+      end
+
+      # Render a batch of events for a lane.
+      # alive: true  → lane still in flight (lifecycle prefix)
+      # alive: false → lane finished (terminal line included)
+      # Returns a String (may be empty).
+      def render(lane:, events:, alive:)
+        return "" if @level == 0 && !@jsonl
+
+        if @jsonl
+          return events.map { |ev| "[#{lane}] #{JSON.generate(ev)}" }.join("\n").then { |s| s.empty? ? s : "#{s}\n" }
+        end
+
+        lines = []
+        terminal = nil
+
+        events.each do |ev|
+          case ev["type"]
+          when "assistant"
+            Array(ev.dig("message", "content")).each do |block|
+              case block["type"]
+              when "thinking"
+                lines << "[#{lane}] #{block['thinking'].to_s.strip}" if @thinking && @level >= 1
+              when "text"
+                lines << "[#{lane}] #{block['text'].to_s.strip}" if @level >= 2
+              when "tool_use"
+                if @level >= 3
+                  name_line = "[#{lane}] tool: #{block['name']}"
+                  if @level >= 4
+                    input = block["input"]
+                    name_line += " #{JSON.generate(input)}" if input && !input.empty?
+                  end
+                  lines << name_line
+                end
+              end
+            end
+          when "user"
+            Array(ev.dig("message", "content")).each do |block|
+              next unless block["type"] == "tool_result"
+              next unless @level >= 4
+
+              content = block["content"]
+              lines << "[#{lane}] tool_result: #{content.to_s.strip}"
+            end
+          when "result"
+            terminal = ev
+          end
+        end
+
+        if terminal
+          lines << terminal_line(lane, terminal)
+        elsif alive && @level >= 1 && events.empty?
+          lines << "[#{lane}] running"
+        end
+
+        lines.reject(&:empty?).join("\n").then { |s| s.empty? ? s : "#{s}\n" }
+      end
+
+      def lifecycle?
+        @level >= 1 && !@jsonl
+      end
+
+      private
+
+      def terminal_line(lane, ev)
+        if ev["is_error"]
+          reason = ev["result"].to_s.strip
+          reason = ev["subtype"] if reason.empty?
+          "[#{lane}] ✗ failed #{reason}"
+        elsif ev["subtype"] == "success"
+          dur   = ev["duration_ms"] ? "#{(ev['duration_ms'] / 1000.0).round(1)}s" : "-"
+          turns = ev["num_turns"] || "-"
+          result_snip = ev["result"].to_s.strip.slice(0, 80)
+          "[#{lane}] ✓ complete · STATUS: #{result_snip} · #{dur} · #{turns} turns"
+        else
+          "[#{lane}] ⚠ nonzero exit"
+        end
+      end
+    end
+  end
+end

data/lib/space_architect/research/run.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Space::Architect
+  module Research
+    Run = Data.define(:id, :topic, :pid, :dir, :prompt_path, :run_log_path, :report_path, :model, :dispatched_at)
+  end
+end

data/lib/space_architect/research/supervisor.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "time"
+
+module Space::Architect
+  module Research
+    class Supervisor
+      DEFAULT_MODEL     = Harness::CLAUDE_DEFAULT_MODEL
+      DEFAULT_MAX_TURNS = 40
+
+      def initialize(space:, bin: nil)
+        @space    = space
+        @bin      = bin
+        @registry = Registry.new(space.path.join("build", "research", "registry.yaml"))
+      end
+
+      # Dispatch each prompt file as a detached read-only claude -p child.
+      # Returns array of Run objects (non-blocking).
+      def dispatch(prompts, model: DEFAULT_MODEL, max_turns: DEFAULT_MAX_TURNS)
+        prompts.map { |path| dispatch_one(Pathname.new(path), model: model, max_turns: max_turns) }
+      end
+
+      # Classify each registered run and return per-run state hashes.
+      def status
+        @registry.all.map do |run|
+          state = classify(run)
+          tail  = tail_lines(run.run_log_path, 5)
+          { run: run, state: state, tail: tail }
+        end
+      end
+
+      # Async mux: tail all runs to terminal. Returns :ok or :failed.
+      def wait(quiet: false, level: 1, thinking: false, jsonl: false, out: $stdout)
+        effective_level = quiet ? 0 : level
+        renderer = Renderer.new(level: effective_level, thinking: thinking, jsonl: jsonl)
+        runs = @registry.all
+        return :ok if runs.empty?
+
+        Mux.new(runs, renderer: renderer, out: out).run
+      end
+
+      private
+
+      def dispatch_one(path, model:, max_turns:)
+        id    = derive_id(path)
+        topic = id.sub(/\A\d+-/, "")
+        dir   = @space.path.join("build", "research", id)
+        FileUtils.mkdir_p(dir)
+
+        prompt_path  = dir.join("prompt.md")
+        run_log_path = dir.join("run.jsonl")
+        report_path  = dir.join("report.md")
+
+        FileUtils.cp(path.to_s, prompt_path.to_s)
+
+        harness = Harness::ClaudeCodeHarness.new(
+          model:            model,
+          max_turns:        max_turns,
+          bin:              @bin,
+          allowed_tools:    READONLY_TOOLS,
+          disallowed_tools: ""
+        )
+
+        pid = harness.run_detached(
+          prompt_path:  prompt_path,
+          run_log_path: run_log_path,
+          chdir:        @space.path
+        )
+
+        run = Run.new(
+          id:            id,
+          topic:         topic,
+          pid:           pid,
+          dir:           dir,
+          prompt_path:   prompt_path,
+          run_log_path:  run_log_path,
+          report_path:   report_path,
+          model:         model,
+          dispatched_at: Time.now
+        )
+        @registry.add(run)
+        run
+      end
+
+      def derive_id(path)
+        File.basename(path.to_s).sub(/\.prompt\.md\z/, "").sub(/\.md\z/, "")
+      end
+
+      def classify(run)
+        content = File.exist?(run.run_log_path.to_s) ? File.read(run.run_log_path.to_s) : ""
+        events  = content.lines.filter_map { |l| JSON.parse(l.chomp) rescue nil }
+        terminal = events.find { |e| e["type"] == "result" }
+
+        return :complete if terminal && !terminal["is_error"]
+        return :failed   if terminal && terminal["is_error"]
+
+        pid_alive = begin; Process.kill(0, run.pid); true; rescue Errno::ESRCH, Errno::EPERM; false; end
+        pid_alive ? :running : :failed
+      end
+
+      def tail_lines(path, n)
+        return [] unless File.exist?(path.to_s)
+        File.readlines(path.to_s).last(n).map(&:chomp)
+      end
+    end
+  end
+end

data/lib/space_architect/research.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Space::Architect
+  module Research
+    READONLY_TOOLS = "Read,Grep,Glob,WebSearch,WebFetch"
+  end
+end
+
+require_relative "research/run"
+require_relative "research/registry"
+require_relative "research/renderer"
+require_relative "research/mux"
+require_relative "research/supervisor"