space-architect 7.1.0 → 9.0.0

data/lib/space_architect/pi/builder-guard.ts

@@ -0,0 +1,103 @@
+// Builder guard: injected with every architect dispatch (`pi -e <path>`) to
+// deny, before evaluation, the two failure modes a hermetic builder must not
+// reach: git writes (the architect CLI owns all commits in a lane worktree)
+// and commands bash cannot parse (a parse error at tool time burns a turn).
+// Parse-level only: `bash -n` cannot catch runtime failures — those are the
+// bash tool's own domain.
+import { spawnSync } from "node:child_process";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+// Git subcommands that mutate repository state. Reads (log, diff, show, …)
+// stay allowed — only the write verbs are denied.
+const GIT_WRITE_VERBS = new Set([
+	"commit",
+	"push",
+	"pull",
+	"reset",
+	"merge",
+	"rebase",
+	"checkout",
+	"switch",
+	"branch",
+	"tag",
+	"cherry-pick",
+	"revert",
+	"stash",
+	"worktree",
+	"clean",
+	"restore",
+	"rm",
+	"mv",
+	"am",
+	"apply",
+]);
+
+// Global flags that consume a following value, when locating the subcommand —
+// `git -C <path> commit` must classify as commit (flags sit between `git` and
+// the subcommand, so an adjacency pattern misses it).
+const GIT_VALUE_FLAGS = new Set(["-C", "-c"]);
+
+// Split a command line into simple-command segments at the shell's command
+// separators. Whitespace tokenization only: this is a deny list, not a shell
+// reimplementation, and the deny decision never depends on quoting structure
+// beyond what the separator split already crossed.
+function segments(command: string): string[] {
+	return command.split(/\r?\n|\|\||&&|[;|]/);
+}
+
+// The git subcommand a segment invokes, or null: walk the tokens after `git`,
+// skipping global flags (and their values) so the first positional token is
+// the subcommand. Never substring-match the raw command — `git log
+// --grep=commit` mentions `commit` but is a read.
+function gitSubcommand(segment: string): string | null {
+	const tokens = segment.trim().split(/\s+/);
+	if (tokens[0] !== "git") return null;
+
+	for (let i = 1; i < tokens.length; i++) {
+		const tok = tokens[i];
+		if (!tok.startsWith("-")) return tok;
+		if (GIT_VALUE_FLAGS.has(tok)) i++; // skip the flag's value
+	}
+	return null;
+}
+
+function gitWriteDenial(command: string): string | null {
+	for (const segment of segments(command)) {
+		const sub = gitSubcommand(segment);
+		if (sub && GIT_WRITE_VERBS.has(sub)) {
+			return `git ${sub} writes repository state — the architect CLI owns all commits and git mutations; ` +
+				`leave repository state alone and report what you would have run`;
+		}
+	}
+	return null;
+}
+
+// Parse-check via `bash -n`: stdin carries the command, stderr is the reason.
+function parseDenial(command: string): string | null {
+	const check = spawnSync("bash", ["-n"], { input: command, encoding: "utf8" });
+	if (check.status === 0) return null;
+	return `command does not parse under \`bash -n\` and would burn a turn at tool time; ` +
+		`fix the command's syntax — bash said: ${(check.stderr ?? "").trim()}`;
+}
+
+export default function builderGuard(pi: ExtensionAPI): void {
+	pi.on("tool_call", (event) => {
+		// bash only: the deny list is shell-command shaped; edit/write tools are
+		// bounded by the lane's touch set, not this guard.
+		if (event.toolName !== "bash") return;
+		const command = (event.input as { command?: unknown }).command;
+		if (typeof command !== "string") return;
+
+		// Test the command string itself, never the JSON-rendered whole input —
+		// a payload that merely mentions `git commit` in prose must not match.
+		const denial = gitWriteDenial(command) ?? parseDenial(command);
+		if (denial) {
+			return {
+				block: true,
+				// The reason is the builder's only feedback: it must say what was
+				// denied and what to do instead.
+				reason: `architect builder guard: ${denial}`,
+			};
+		}
+	});
+}

data/lib/space_architect/research/mux.rb

@@ -11,10 +11,12 @@ module Space::Architect
       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
+      # heartbeat_every: test seam — defaults to HEARTBEAT_EVERY.
+      def initialize(runs, renderer:, out: $stdout, heartbeat_every: HEARTBEAT_EVERY)
+        @runs            = runs
+        @renderer        = renderer
+        @out             = out
+        @heartbeat_every = heartbeat_every
       end
 
       # Returns :ok or :failed
@@ -35,7 +37,7 @@ module Space::Architect
         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))
+          emit(@renderer.terminal(lane: run.id, ok: false, reason: "run.jsonl never appeared"))
           return :failed
         end
 
@@ -43,7 +45,7 @@ module Space::Architect
 
         events_all = []
         last_emit  = Time.now
-        terminal   = nil
+        settled    = nil
 
         File.open(run.run_log_path.to_s, "r") do |f|
           loop do
@@ -53,30 +55,29 @@ module Space::Architect
               next unless ev
 
               events_all << ev
-              terminal = ev if ev["type"] == "result"
+              settled = ev if ev["type"] == "agent_settled"
 
               new_events = [ev]
-              rendered = @renderer.render(lane: run.id, events: new_events, alive: terminal.nil?)
+              rendered = @renderer.render(lane: run.id, events: new_events, alive: settled.nil?)
               emit(rendered) unless rendered.empty?
               last_emit = Time.now
 
-              break if terminal
+              break if settled
             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))
+                unless settled
+                  emit(@renderer.terminal(lane: run.id, ok: false,
+                                          reason: "process died without a terminal event"))
                   return :failed
                 end
                 break
               end
 
-              if Time.now - last_emit > HEARTBEAT_EVERY
+              if Time.now - last_emit > @heartbeat_every
                 emit("[#{run.id}] ⏳ still running…\n") if @renderer.lifecycle?
                 last_emit = Time.now
               end
@@ -86,14 +87,36 @@ module Space::Architect
           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
+        finish(run, events_all, settled)
+      end
+
+      # Classify the settled stream via PiEvents and render the terminal line.
+      def finish(run, events, settled)
+        text   = PiEvents.message_text(PiEvents.last_assistant_message(events))
+        outcome, reason = classify(events, settled, text)
+
+        extract_report(run, text) unless text.empty?
+
+        emit(@renderer.terminal(lane: run.id, ok: outcome == :ok,
+                                reason:  outcome == :ok ? nil : reason,
+                                snippet: outcome == :ok ? text : nil,
+                                duration: PiEvents.duration_seconds(events),
+                                turns:    PiEvents.turn_count(events)))
+        outcome
+      end
+
+      # :ok iff the stream settled un-aborted, the last assistant stopReason is
+      # "stop", and the final assistant text is non-empty; :failed with a named
+      # reason otherwise.
+      def classify(events, settled, text)
+        reason = PiEvents.stop_reason(events)
+
+        return [:failed, text.empty? ? "aborted" : text] if settled.is_a?(Hash) && settled["aborted"] == true
+        return [:ok, text] if reason == "stop" && !text.empty?
+        return [:failed, text.empty? ? reason : text] if PiEvents.failed_stop_reason?(reason)
+
+        # "stop" or no assistant message at all, but no final text.
+        [:failed, "no final assistant text"]
       end
 
       def wait_for_file(run)
@@ -105,16 +128,8 @@ module Space::Architect
         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 }
+      def extract_report(run, text)
+        Pathname.new(run.report_path).write(text)
       end
 
       def emit(text)

data/lib/space_architect/research/pi_events.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Space::Architect
+  module Research
+    # Pure helpers over pi's JSONL event stream — parsed event hashes in, values
+    # out, no I/O. The one home for the pi-shape predicates: Mux, report
+    # extraction, and Supervisor#classify all consume these, so the terminal
+    # classification is not duplicated per call site.
+    module PiEvents
+      # pi's StopReason values that mean the assistant did not finish normally.
+      FAILED_STOP_REASONS = %w[error aborted].freeze
+
+      module_function
+
+      # Assistant `message_end` messages, in stream order — the sole source of
+      # complete message content (`message_start`/`message_update` are inert;
+      # `turn_end`/`agent_end` only replay).
+      def assistant_messages(events)
+        events.filter_map do |e|
+          next unless e.is_a?(Hash) && e["type"] == "message_end" &&
+                      e["message"].is_a?(Hash) && e["message"]["role"] == "assistant"
+          e["message"]
+        end
+      end
+
+      def last_assistant_message(events)
+        assistant_messages(events).last
+      end
+
+      # The last assistant message's stopReason ("stop"/"error"/"aborted"), or
+      # nil when the stream has no assistant message_end.
+      def stop_reason(events)
+        last_assistant_message(events)&.fetch("stopReason", nil)
+      end
+
+      def failed_stop_reason?(reason)
+        FAILED_STOP_REASONS.include?(reason)
+      end
+
+      # Joined text blocks of a message — the report source.
+      def message_text(message)
+        return "" unless message.is_a?(Hash)
+        Array(message["content"]).select { |b| b.is_a?(Hash) && b["type"] == "text" }
+                                 .map { |b| b["text"].to_s }
+                                 .join
+      end
+
+      # Run span in whole-tenths of a second: last assistant message_end
+      # `.timestamp` (epoch ms) minus `session.timestamp` (ISO 8601). NOT a sum
+      # of per-response durationMs — that omits tool time between turns.
+      def duration_seconds(events)
+        session = events.find { |e| e.is_a?(Hash) && e["type"] == "session" }
+        end_ms  = last_assistant_message(events)&.fetch("timestamp", nil)
+        return nil unless session.is_a?(Hash) && session["timestamp"].is_a?(String) && end_ms.is_a?(Numeric)
+
+        start_s = Time.iso8601(session["timestamp"]).to_f
+        ((end_ms / 1000.0) - start_s).round(1)
+      rescue ArgumentError
+        nil
+      end
+
+      # One turn_end per turn.
+      def turn_count(events)
+        events.count { |e| e.is_a?(Hash) && e["type"] == "turn_end" }
+      end
+    end
+  end
+end

data/lib/space_architect/research/renderer.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require "json"
+
 module Space::Architect
   module Research
-    # Pure, testable verbosity-gated renderer for stream-json events.
+    # Pure, testable verbosity-gated renderer for pi JSONL events.
     #
     # Levels (§5.3 ladder):
     #   0 (quiet)  — nothing
@@ -22,8 +24,8 @@ module Space::Architect
 
       # 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).
+      # alive: false → lane finished
+      # Returns a String (may be empty). Terminal lines come from #terminal.
       def render(lane:, events:, alive:)
         return "" if @level == 0 && !@jsonl
 
@@ -32,69 +34,67 @@ module Space::Architect
         end
 
         lines = []
-        terminal = nil
-
         events.each do |ev|
           case ev["type"]
-          when "assistant"
+          when "message_end"
+            next unless ev.dig("message", "role") == "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"
+              when "toolCall"
                 if @level >= 3
                   name_line = "[#{lane}] tool: #{block['name']}"
                   if @level >= 4
-                    input = block["input"]
-                    name_line += " #{JSON.generate(input)}" if input && !input.empty?
+                    arguments = block["arguments"]
+                    name_line += " #{JSON.generate(arguments)}" if arguments && !arguments.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}"
+          when "tool_execution_start"
+            if @level >= 3
+              line = "[#{lane}] tool: #{ev['toolName']}"
+              if @level >= 4
+                args = ev["args"]
+                line += " #{JSON.generate(args)}" if args && !args.empty?
+              end
+              lines << line
+            end
+          when "tool_execution_end"
+            if @level >= 4
+              text = Array(ev.dig("result", "content")).select { |c| c.is_a?(Hash) && c["type"] == "text" }
+                                                     .map { |c| c["text"].to_s }.join
+              lines << "[#{lane}] tool_result: #{text.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 << "[#{lane}] running" if alive && @level >= 1 && events.empty?
 
         lines.reject(&:empty?).join("\n").then { |s| s.empty? ? s : "#{s}\n" }
       end
 
-      def lifecycle?
-        @level >= 1 && !@jsonl
-      end
+      # The terminal line, fed terminal FACTS by the mux (never a fabricated
+      # event): ok/failed, the failure reason or the final-text snippet, the
+      # run span, and the turn count.
+      def terminal(lane:, ok:, reason: nil, snippet: nil, duration: nil, turns: nil)
+        return "" if @level == 0 || @jsonl
 
-      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"
+        line = if ok
+          span  = duration ? "#{duration}s" : "-"
+          "[#{lane}] ✓ complete · STATUS: #{snippet.to_s.strip.slice(0, 80)} · #{span} · #{turns || '-'} turns"
         else
-          "[#{lane}] ⚠ nonzero exit"
+          "[#{lane}] ✗ failed #{reason.to_s.strip}"
         end
+        "#{line}\n"
+      end
+
+      def lifecycle?
+        @level >= 1 && !@jsonl
       end
     end
   end

data/lib/space_architect/research/supervisor.rb

@@ -1,22 +1,27 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "pathname"
 require "time"
 
 module Space::Architect
   module Research
     class Supervisor
-      DEFAULT_MODEL     = Harness::CLAUDE_DEFAULT_MODEL
+      DEFAULT_MODEL     = Harness::DEFAULT_MODEL
       DEFAULT_MAX_TURNS = 40
 
+      # The vendored builder-guard extension ships in the gem next to this file's
+      # sibling pi/ dir — copied per-run and injected with the harness.
+      VENDORED_GUARD = Pathname.new(__dir__).join("../pi/builder-guard.ts")
+
       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).
+      # Dispatch each prompt file as a detached pi 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
@@ -54,12 +59,19 @@ module Space::Architect
 
         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: ""
+        # Vendor the guard into the run dir (idempotent overwrite) and inject it via
+        # the harness — research runs get the same deny-only builder guard.
+        guard_path = dir.join("builder-guard.ts")
+        FileUtils.cp(VENDORED_GUARD, guard_path)
+
+        # config_dir: is pi's --session-dir — research sessions land under
+        # build/research/<id>/ instead of ~/.pi/agent/sessions/.
+        harness = Harness::PiHarness.new(
+          model:      model,
+          max_turns:  max_turns,
+          bin:        @bin,
+          config_dir: dir,
+          guard_path: guard_path
         )
 
         pid = harness.run_detached(
@@ -87,18 +99,27 @@ module Space::Architect
         File.basename(path.to_s).sub(/\.prompt\.md\z/, "").sub(/\.md\z/, "")
       end
 
+      # pi has no terminal "result" event: the run's outcome is the LAST assistant
+      # message's stopReason ("stop" finished normally; "error"/"aborted" failed —
+      # pi's StopReason vocabulary; PiEvents is the one home for these
+      # predicates). Without one, a live pid is still running and a dead pid
+      # died without finishing.
       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" }
+        events = read_events(run.run_log_path)
+        reason = PiEvents.stop_reason(events)
 
-        return :complete if terminal && !terminal["is_error"]
-        return :failed   if terminal && terminal["is_error"]
+        return :complete if reason == "stop"
+        return :failed   if PiEvents.failed_stop_reason?(reason)
 
         pid_alive = begin; Process.kill(0, run.pid); true; rescue Errno::ESRCH, Errno::EPERM; false; end
         pid_alive ? :running : :failed
       end
 
+      def read_events(path)
+        return [] unless File.exist?(path.to_s)
+        File.readlines(path.to_s).filter_map { |l| JSON.parse(l.chomp) rescue nil }
+      end
+
       def tail_lines(path, n)
         return [] unless File.exist?(path.to_s)
         File.readlines(path.to_s).last(n).map(&:chomp)

data/lib/space_architect/research.rb

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

data/lib/space_architect/session_sync/bin_path.rb

@@ -5,7 +5,7 @@ require "open3"
 module Space::Architect
   module SessionSync
     # Resolves the absolute path to the `architect` executable the plist
-    # should invoke, imitating Space::Src::CLI::Daemon::Helpers::Resolve's
+    # should invoke, imitating RepoTender::CLI::Daemon::Helpers::Resolve's
     # detect_bin_path precedence: an env override (tests), the dev checkout's
     # exe/architect, `which architect`, then the installed gem's bin.
     module BinPath

data/lib/space_architect/session_sync/cursor.rb

@@ -6,7 +6,7 @@ require "fileutils"
 module Space::Architect
   module SessionSync
     # Machine-managed cursor at $XDG_STATE_HOME/space-architect/session-sync.yaml
-    # (imitates Space::Src::State::Store's load/write/emit shape). Keyed by
+    # (imitates RepoTender::State::Store's load/write/emit shape). Keyed by
     # absolute source path; each entry records the size + mtime observed the
     # last time that file was uploaded.
     class Cursor

data/lib/space_architect/session_sync/plist.rb

@@ -3,7 +3,7 @@
 module Space::Architect
   module SessionSync
     # Hand-rolled launchd plist emitter for the session-sync agent, imitating
-    # Space::Src::Launchd::Plist's shape. Under launchd's bare PATH, a bare
+    # RepoTender::Launchd::Plist's shape. Under launchd's bare PATH, a bare
     # env-relative ruby binstub shebang resolves to macOS system Ruby instead
     # of the caller's toolchain, so ProgramArguments names the interpreter
     # explicitly (ruby_bin) rather than relying on shebang resolution — no

data/lib/{space_core → space_architect}/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Space
-  module Core
-    VERSION = "7.1.0"
+  module Architect
+    VERSION = "9.0.0"
   end
 end

data/lib/space_architect.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
 require "space_core"
-require "space_src"
+require_relative "space_architect/version"
 
 require_relative "space_architect/harness"
 require_relative "space_architect/run_creator"
-require_relative "space_architect/dispatcher"
 require_relative "space_architect/gate_lint"
 require_relative "space_architect/gate_evaluator"
 require_relative "space_architect/architect_project"