space-architect 7.1.0 → 9.0.0

data/lib/space_architect/architect_project.rb

@@ -241,13 +241,6 @@ module Space::Architect
           lanes = s["lanes"] || []
           declared.each do |d|
             fields = { "name" => d["name"], "repo" => d["repo"], "touch_set" => Array(d["touch"]) }
-            # #89/AC3-AC4: the frozen lane's own tool grant, reviewable like every other
-            # boundary. Declared-only, like touch_set — worktree_add never touches these
-            # keys, so a re-materialize preserves them without threading them through
-            # recorded_lane_fields (unlike harness/model, which worktree_add resolves and
-            # overwrites on every call).
-            fields["allowed_tools"]        = d["allowed_tools"]        if d["allowed_tools"]
-            fields["append_allowed_tools"] = d["append_allowed_tools"] if d["append_allowed_tools"]
             existing = lanes.find { |l| l["name"] == d["name"] }
             existing ? existing.merge!(fields) : lanes << fields
           end
@@ -841,7 +834,7 @@ module Space::Architect
         variants: variant_lanes.map do |l|
           {
             name:               l["name"],
-            harness:            l["harness"] || "claude-code",
+            harness:            l["harness"] || "pi",
             model:              l["model"],
             effort:             l["effort"],
             base_sha:           l["base_sha"],
@@ -940,9 +933,8 @@ module Space::Architect
       end
     end
 
-    def dispatch(iteration, lane, model: nil, max_turns: 200,
-                 claude_bin: nil, harness: nil, opencode_bin: nil, effort: nil,
-                 allowed_tools: nil, append_allowed_tools: nil, force: false, quiet: false,
+    def dispatch(iteration, lane, model: nil, max_turns: 200, bin: nil, harness: nil, effort: nil,
+                 force: false, quiet: false,
                  detach: false, push_url: nil, push_token: nil, push_host: nil, run_creator: nil,
                  push_client: nil, timeout: nil, prompt: nil, now: Time.now)
       raise Space::Core::Error, "Specify --push-host or --push-url, not both" if push_host && push_url
@@ -959,12 +951,6 @@ module Space::Architect
 
       resolved_harness, resolved_model, resolved_effort =
         resolve_dispatch_harness(lane_entry, model: model, harness: harness, effort: effort, force: force, err: err)
-      resolved_allowed_tools, replace_tools, append_tools, tools_provenance =
-        resolve_allowed_tools(lane_entry, allowed_tools: allowed_tools, append_allowed_tools: append_allowed_tools)
-      err.puts(tools_provenance) if replace_tools || append_tools
-
-      raise Space::Core::Error, "--push-host is only supported with the claude-code harness" \
-        if push_host && resolved_harness != "claude-code"
 
       id = iteration_id(entry)
       wt_path = space.path.join(lane_entry["worktree"] || "build/#{id}-#{lane}/wt")
@@ -979,31 +965,31 @@ module Space::Architect
       # and the CLI owns the canonical copy — byte-for-byte, like variant_add.
       copy_and_validate_prompt!(prompt, prompt_path)
 
-      bin = resolved_harness == "claude-code" ? claude_bin : opencode_bin
+      # Vendor the builder guard into the lane's build dir (idempotent overwrite) and
+      # inject it via -e on every dispatch — blocking and detached alike. The guard
+      # denies git-write and bash-unparseable commands before evaluation; the builder
+      # itself never needs to remember to load it.
+      guard_path = build_dir.join("builder-guard.ts")
+      FileUtils.cp(vendored_guard_path, guard_path)
+
       harness_obj = Harness.for(resolved_harness, model: resolved_model, max_turns: max_turns, bin: bin,
                                                   config_dir: build_dir, effort: resolved_effort,
-                                                  allowed_tools: resolved_allowed_tools, force: force, err: err)
+                                                  guard_path: guard_path, force: force, err: err)
 
-      # Stamp launch time and the resolved harness/model/effort/allowed_tools onto the
+      # Stamp launch time and the resolved harness/model/effort onto the
       # lane entry: after every preflight validation has passed (a dispatch that raises
       # above records nothing) and before the blocking run or a detached dispatch
       # returns. A re-dispatch overwrites the prior values, so `architect status`
-      # always reads what actually ran on the last dispatch. #89/AC8: the resolved
-      # tool grant is recorded the same way, so a denial traces back to a grant a
-      # human can read — replace_tools/append_tools are the pre-composition components
-      # (not the harness's expanded ClaudeCodeHarness.resolve_tools result), so a later
-      # bare re-dispatch re-resolves from the same components instead of compounding.
+      # always reads what actually ran on the last dispatch.
       update_architect_block do |b|
         (b["iterations"] || []).each do |s|
           next unless s["name"] == iteration
           (s["lanes"] || []).each do |l|
             next unless l["name"] == lane
-            l["dispatched_at"]         = now.iso8601
-            l["harness"]               = resolved_harness
-            l["model"]                 = resolved_model
-            l["effort"]                = resolved_effort if resolved_effort
-            l["allowed_tools"]         = replace_tools    if replace_tools
-            l["append_allowed_tools"]  = append_tools     if append_tools
+            l["dispatched_at"] = now.iso8601
+            l["harness"]       = resolved_harness
+            l["model"]         = resolved_model
+            l["effort"]        = resolved_effort if resolved_effort
           end
         end
         b
@@ -1028,96 +1014,30 @@ module Space::Architect
 
         run_kwargs = { prompt_path: prompt_path, run_log_path: run_log_path, chdir: wt_path }
         run_kwargs[:timeout] = timeout if timeout
-        if resolved_harness == "claude-code"
-          run_kwargs[:push_url]    = push_url    if push_url
-          run_kwargs[:push_token]  = push_token  if push_token
-          run_kwargs[:push_client] = push_client if push_client
-          run_kwargs[:err]         = err         if quiet
-        end
+        run_kwargs[:push_url]    = push_url    if push_url
+        run_kwargs[:push_token]  = push_token  if push_token
+        run_kwargs[:push_client] = push_client if push_client
+        run_kwargs[:err]         = err         if quiet
         exit_code = harness_obj.run(**run_kwargs)
 
         result = { exit_code: exit_code, run_log: run_log_path, report: report_path, worktree: wt_path }
         result[:prompt_copied]  = prompt_path    if prompt
-        result[:timed_out]      = true           if exit_code == Harness::ClaudeCodeHarness::TIMEOUT_EXIT_CODE
+        result[:timed_out]      = true           if exit_code == Harness::PiHarness::TIMEOUT_EXIT_CODE
         result[:created_run_id] = created_run_id if created_run_id
         result[:push_url]       = push_url       if push_url
         result
       end
     end
 
-    # Submit the lane's builder run as a job to the space-server's queue instead of
-    # running it locally: the sandboxed executor mounts the lane worktree + the repo
-    # checkout at their identical host absolute paths (so the worktree's gitdir
-    # pointer resolves) and runs the harness itself — no local run.jsonl, the
-    # transcript lives server-side. jobs_client: is the injectable seam (mirrors
-    # dispatch's run_creator:).
-    def dispatch_as_job(iteration, lane, host:, token:, backend_url:, model: nil, harness: nil,
-                        max_turns: 200, effort: nil, allowed_tools: nil, append_allowed_tools: nil,
-                        force: false, quiet: false,
-                        job_model: nil, api_key_ref: nil, prompt: nil, jobs_client: nil, now: Time.now)
-      err = quiet ? File.open(File::NULL, "w") : $stderr
-
-      entry = slice_entry(iteration)
-      lane_entry = (entry["lanes"] || []).find { |l| l["name"] == lane }
-      raise Space::Core::Error, "No lane '#{lane}' recorded for iteration '#{iteration}'" unless lane_entry
-      lane_entry = ensure_lane_materialized(iteration, lane)
-
-      resolved_harness, resolved_model, resolved_effort =
-        resolve_dispatch_harness(lane_entry, model: model, harness: harness, effort: effort, force: force, err: err)
-      raise Space::Core::Error, "--as-job only supports the claude-code harness (lane '#{lane}' resolves to '#{resolved_harness}')" \
-        unless resolved_harness == "claude-code"
-      raise Space::Core::Error, "--job-model is required with --as-job" unless job_model
-
-      # #89: same replace/append resolution as the local dispatch path — the sandboxed
-      # executor still runs `claude -p` with harness_args server-side.
-      resolved_allowed_tools, replace_tools, append_tools, tools_provenance =
-        resolve_allowed_tools(lane_entry, allowed_tools: allowed_tools, append_allowed_tools: append_allowed_tools)
-      err.puts(tools_provenance) if replace_tools || append_tools
-
-      id = iteration_id(entry)
-      wt_path = space.path.join(lane_entry["worktree"] || "build/#{id}-#{lane}/wt")
-      raise Space::Core::Error, "Worktree directory does not exist: #{wt_path}" unless wt_path.exist?
-
-      build_dir   = space.path.join("build", "#{id}-#{lane}")
-      prompt_path = build_dir.join("prompt.md")
-      copy_and_validate_prompt!(prompt, prompt_path)
-
-      repo_path   = space.path.join("repos", lane_entry["repo"])
-      harness_obj = Harness.for(resolved_harness, model: resolved_model, max_turns: max_turns,
-                                                  effort: resolved_effort, allowed_tools: resolved_allowed_tools,
-                                                  force: force, err: err)
-
-      spec = job_spec(iteration: iteration, lane: lane, wt_path: wt_path, build_dir: build_dir,
-        repo_path: repo_path, prompt_content: prompt_path.read, backend_url: backend_url,
-        job_model: job_model, api_key_ref: api_key_ref, harness_args: harness_obj.builder_args)
-
-      client = jobs_client || JobsClient.new(host, token)
-      job_id = client.create(spec)
-
-      # Dispatch bookkeeping, mirroring the local path's dispatched_at stamp: a
-      # re-dispatch overwrites the prior job_id, so `architect status` always
-      # reflects the last dispatch regardless of mode.
-      update_architect_block do |b|
-        (b["iterations"] || []).each do |s|
-          next unless s["name"] == iteration
-          (s["lanes"] || []).each do |l|
-            next unless l["name"] == lane
-            l["dispatched_at"] = now.iso8601
-            l["job_id"]        = job_id
-          end
-        end
-        b
-      end
-
-      result = { job_id: job_id, spec: spec }
-      result[:prompt_copied] = prompt_path if prompt
-      result
-    end
-
     private
 
     attr_reader :space
 
+    # The vendored builder-guard extension shipped in the gem (lib/space_architect/pi/).
+    def vendored_guard_path
+      Pathname.new(__dir__).join("pi/builder-guard.ts")
+    end
+
     # Compose a commit message. Without a custom message, the canonical default
     # (unchanged). With one, a short canonical prefix keeps the loop's commit
     # taxonomy grep-able while the author's first line owns the subject; any
@@ -1685,23 +1605,23 @@ module Space::Architect
     end
 
     # Resolve harness + model by precedence: explicit value > (dispatch only) the
-    # lane's stored value > space.yaml project.harness/project.model > the
-    # per-harness sensible default (model only, keyed on the resolved harness).
-    # Shared by worktree_add and dispatch so both read the same defaults. A stored
-    # model is only honored when its stored harness still matches the resolved
-    # harness — a dispatch-time harness override drops the old harness's stored
-    # model instead of leaking it into the new harness's run.
+    # lane's stored value > space.yaml project.harness/project.model > the pi
+    # default model. Shared by worktree_add and dispatch so both read the same
+    # defaults. A stored model is only honored when its stored harness still matches
+    # the resolved harness — a dispatch-time harness override drops the old harness's
+    # stored model instead of leaking it into the new harness's run. A stored
+    # legacy harness name survives resolution (so a stale space.yaml
+    # surfaces as Harness.for's actionable pi-only error, not a silent default).
     def resolve_harness_model(harness, model, stored_harness: nil, stored_model: nil)
       defaults = project_defaults
-      resolved_harness = (harness || stored_harness || defaults["harness"] || "claude-code").to_s
+      resolved_harness = (harness || stored_harness || defaults["harness"] || "pi").to_s
       stored_model = nil unless stored_harness.nil? || stored_harness.to_s == resolved_harness
-      resolved_model = model || stored_model || defaults["model"] || Harness.default_model_for(resolved_harness)
+      resolved_model = model || stored_model || defaults["model"] || Harness::DEFAULT_MODEL
       [resolved_harness, resolved_model]
     end
 
     # --prompt: the caller authors the lane prompt anywhere (a fresh scratch file) and
-    # the CLI owns the canonical copy — byte-for-byte, like variant_add. Shared by
-    # dispatch and dispatch_as_job so both refuse the same empty/stub prompt.
+    # the CLI owns the canonical copy — byte-for-byte, like variant_add.
     def copy_and_validate_prompt!(prompt, prompt_path)
       if prompt
         src = Pathname.new(prompt)
@@ -1716,8 +1636,8 @@ module Space::Architect
         if prompt_content.empty? || prompt_content == PROMPT_STUB.strip
     end
 
-    # Resolve harness/model/effort for a dispatch (local or --as-job), shared so the
-    # two dispatch paths can never drift on precedence or thinking-level translation.
+    # Resolve harness/model/effort for a dispatch, so every dispatch path reads
+    # precedence and thinking-level translation from one place.
     def resolve_dispatch_harness(lane_entry, model:, harness:, effort:, force:, err:)
       model, suffix_level = Harness.parse_model_suffix(model)
       resolved_harness, resolved_model = resolve_harness_model(harness, model,
@@ -1737,69 +1657,9 @@ module Space::Architect
       [resolved_harness, resolved_model, resolved_effort]
     end
 
-    # #89/AC1-AC5: resolve the claude-code --allowedTools grant for a dispatch (local or
-    # --as-job), shared so both paths resolve precedence identically. The CLI flag beats
-    # the lane's recorded allowed_tools:/append_allowed_tools: (frozen-declaration or a
-    # prior dispatch's stamp) — resolved independently for replace vs. append, so a flag
-    # on one axis and a lane value on the other both apply (Objective A). Meaningless for
-    # opencode/pi (no equivalent grant mechanism) — still resolved/recorded for visibility,
-    # but Harness.for only wires it into the claude-code branch's argv.
-    def resolve_allowed_tools(lane_entry, allowed_tools:, append_allowed_tools:)
-      replace, replace_from =
-        if allowed_tools
-          [allowed_tools, "--allowed-tools flag"]
-        elsif lane_entry["allowed_tools"]
-          [lane_entry["allowed_tools"], "lane's allowed_tools:"]
-        else
-          [nil, "default"]
-        end
-
-      append, append_from =
-        if append_allowed_tools
-          [append_allowed_tools, "--append-allowed-tools flag"]
-        elsif lane_entry["append_allowed_tools"]
-          [lane_entry["append_allowed_tools"], "lane's append_allowed_tools:"]
-        end
-
-      final = Harness::ClaudeCodeHarness.resolve_tools(replace: replace, append: append)
-      provenance = "allowed-tools: #{replace_from}#{append_from ? " + #{append_from}" : ""} → #{final}"
-      [final, replace, append, provenance]
-    end
-
-    # Compose a dispatch --as-job spec per the space-server's job contract: prompt +
-    # workspace.dir (the lane worktree) + environment (deps/network/mounts/env or
-    # secrets) + harness (claude/backend/args) + provenance. mounts are src:dst with
-    # src == dst — the sandboxed executor requires the lane worktree AND the repo
-    # checkout mounted at their identical host absolute paths for the worktree's
-    # gitdir pointer to resolve.
-    def job_spec(iteration:, lane:, wt_path:, build_dir:, repo_path:, prompt_content:, backend_url:,
-                job_model:, api_key_ref:, harness_args:)
-      harness = { "type" => "claude", "backend" => { "base_url" => backend_url }, "args" => harness_args }
-      harness["model"] = job_model if job_model
-      harness["backend"]["api_key_ref"] = api_key_ref if api_key_ref
-
-      environment = {
-        "env"  => api_key_ref ? {} : { "ANTHROPIC_API_KEY" => "unused-for-keyless-backends" },
-        "deps" => ["git"],
-        "permissions" => {
-          "network" => true,
-          "mounts"  => ["#{build_dir}:#{build_dir}", "#{repo_path}:#{repo_path}"]
-        }
-      }
-      environment["secrets"] = [{ "ref" => api_key_ref, "name" => "ANTHROPIC_API_KEY" }] if api_key_ref
-
-      {
-        "prompt"      => prompt_content,
-        "workspace"   => { "dir" => wt_path.to_s },
-        "environment" => environment,
-        "harness"     => harness,
-        "provenance"  => { "space" => Space::Core::Slugger.slug(space.title), "iteration" => iteration, "lane" => lane }
-      }
-    end
-
     def recorded_lane_fields(lane_entry)
       {
-        harness: lane_entry["harness"] || "claude-code",
+        harness: lane_entry["harness"] || "pi",
         model:   lane_entry["model"],
         variant: lane_entry["variant"] || false,
         effort:  lane_entry["effort"]

data/lib/space_architect/bug_report.rb

@@ -79,7 +79,8 @@ module Space
           <<~MD
             ## Diagnostics
 
-            - space-architect: #{Space::Core::VERSION}
+            - space-architect: #{Space::Architect::VERSION}
+            - space-cadet: #{Space::Core::VERSION}
             - ruby: #{RUBY_VERSION} (#{RUBY_PLATFORM})
           MD
         end

data/lib/space_architect/cli/architect.rb

@@ -2,7 +2,6 @@
 
 require "json"
 require "fileutils"
-require "space_src/launchd/agent"
 require_relative "../jobs_client"
 require_relative "../conversations_client"
 require_relative "../session_sync"
@@ -12,8 +11,8 @@ module Space::Architect
     # Optional loop-phase DSL on the shared command base, read by
     # Space::Core::CLI::Help to group the help listing. A command may declare
     # `phase <order>, "<Label>"`; groups, and members within a group, sort by
-    # <order>. Only architect commands declare one — space commands leave it nil
-    # and render as the single ungrouped default listing (unchanged).
+    # <order>. Only architect commands declare one — commands without a phase
+    # render as the single ungrouped default listing (unchanged).
     class BaseCommand
       def self.phase(order = nil, label = nil)
         return @phase if order.nil?
@@ -178,18 +177,10 @@ module Space::Architect
                   nn = s["ordinal"] ? format("%02d", s["ordinal"]) : "-"
                   lane_list = s["lanes"] || []
                   lanes_str = lane_list.map do |l|
-                    h = l["harness"] || "claude-code"
-                    m = l["model"]   || Harness.default_model_for(h)
+                    h = l["harness"] || "pi"
+                    m = l["model"]   || Harness::DEFAULT_MODEL
                     eff = l["effort"] ? "·#{l['effort']}" : ""
-                    # #89/AC8: the resolved tool grant, visible next to the other resolved
-                    # values — only when it diverges from the harness default, to keep the
-                    # common case (no lane touches it) uncluttered. Meaningless outside
-                    # claude-code (no equivalent grant mechanism), so shown only there.
-                    tools = if h == "claude-code"
-                      resolved = Harness::ClaudeCodeHarness.resolve_tools(replace: l["allowed_tools"], append: l["append_allowed_tools"])
-                      resolved == Harness::ClaudeCodeHarness::ALLOWED_TOOLS ? "" : "·tools:#{resolved}"
-                    end
-                    "#{l['name']}(#{l['repo']}·#{h}·#{m}#{eff}#{tools})"
+                    "#{l['name']}(#{l['repo']}·#{h}·#{m}#{eff})"
                   end.join(", ")
                   lanes = lane_list.any? { |l| l["variant"] } ? "variant: #{lanes_str}" : lanes_str
                   lanes = "#{lanes} → winner: #{s['winner']}" if s["winner"]
@@ -493,107 +484,68 @@ module Space::Architect
         argument :lane,      required: true,  desc: "Lane name"
         argument :space,     required: false, desc: "Space identifier (default: $PWD)"
         option   :prompt,    default: nil,    desc: "Read the lane prompt from this file (copied byte-for-byte to build/<id>-<lane>/prompt.md)"
-        option   :model,     default: nil,    desc: "Builder model to pin (default: the lane's stored model, else space.yaml project.model, else the per-harness sensible default). Any provider/tier; pin a full id, not a floating alias"
+        option   :model,     default: nil,    desc: "Builder model to pin (default: the lane's stored model, else space.yaml project.model, else the pi default #{Harness::DEFAULT_MODEL}). Any provider/tier; pin a full id, not a floating alias"
         option   :max_turns, default: "200",  desc: "Max turns for the builder"
-        option   :harness,   default: nil,    desc: "Harness override (claude-code, opencode, pi)"
-        option   :allowed_tools,        default: nil, desc: "Comma-separated tool list — replaces the claude-code --allowedTools grant for this dispatch (default: Read,Edit,Write,Grep,Glob,Bash,WebSearch,WebFetch). The lane's frozen allowed_tools: does the same with no flag; this flag wins over that key. Meaningless for opencode/pi"
-        option   :append_allowed_tools, default: nil, desc: "Comma-separated tool list — appends to the claude-code --allowedTools grant for this dispatch (to the flag/lane replace value, or the default). The lane's frozen append_allowed_tools: does the same with no flag; this flag wins over that key. Meaningless for opencode/pi"
-        option   :effort,    default: nil,    desc: "Thinking/reasoning effort level — alias for --thinking/--reasoning (off, minimal, low, medium, high, xhigh, max); translated + clamped to the lane's harness"
-        option   :thinking,  default: nil,    desc: "Thinking/reasoning effort level — alias for --effort/--reasoning (off, minimal, low, medium, high, xhigh, max); translated + clamped to the lane's harness"
-        option   :reasoning, default: nil,    desc: "Thinking/reasoning effort level — alias for --effort/--thinking (off, minimal, low, medium, high, xhigh, max); translated + clamped to the lane's harness"
-        option   :force_effort,    default: nil, desc: "Force the literal level onto the harness flag, skipping architect's clamp — alias for --force-thinking/--force-reasoning (dispatch only; the binary's rejection is final)"
-        option   :force_thinking,  default: nil, desc: "Force the literal level onto the harness flag, skipping architect's clamp — alias for --force-effort/--force-reasoning (dispatch only; the binary's rejection is final)"
-        option   :force_reasoning, default: nil, desc: "Force the literal level onto the harness flag, skipping architect's clamp — alias for --force-effort/--force-thinking (dispatch only; the binary's rejection is final)"
+        option   :harness,   default: nil,    desc: "Harness (pi)"
+        option   :effort,    default: nil,    desc: "Thinking/reasoning effort level — alias for --thinking/--reasoning (off, minimal, low, medium, high, xhigh, max)"
+        option   :thinking,  default: nil,    desc: "Thinking/reasoning effort level — alias for --effort/--reasoning (off, minimal, low, medium, high, xhigh, max)"
+        option   :reasoning, default: nil,    desc: "Thinking/reasoning effort level — alias for --effort/--thinking (off, minimal, low, medium, high, xhigh, max)"
+        option   :force_effort,    default: nil, desc: "Force the literal level onto the --thinking flag, skipping architect's validation — alias for --force-thinking/--force-reasoning (dispatch only; the binary's rejection is final)"
+        option   :force_thinking,  default: nil, desc: "Force the literal level onto the --thinking flag, skipping architect's validation — alias for --force-effort/--force-reasoning (dispatch only; the binary's rejection is final)"
+        option   :force_reasoning, default: nil, desc: "Force the literal level onto the --thinking flag, skipping architect's validation — alias for --force-effort/--force-thinking (dispatch only; the binary's rejection is final)"
         option   :quiet,    type: :boolean, default: false, desc: "Suppress thinking-translation and harness run-time warn lines (liveness/push) on $stderr for this dispatch"
         option   :detach,    type: :boolean, default: false, desc: "Detach the builder process (returns immediately with PID; poll report for completion)"
         option   :timeout,   default: "14400", desc: "Wall-clock timeout in seconds (0 disables; default 4h); foreground only"
         option   :push_url,   default: nil,   desc: "HTTP endpoint for streaming push (POST body to this URL)"
         option   :push_token, default: nil,   desc: "Bearer token for push endpoint authorization"
         option   :push_host,  default: nil,   desc: "Base URL of the ingest server; the CLI creates a run via POST <host>/runs and streams to /runs/<id>/ingest (requires --push-token)"
-        option   :as_job,     type: :boolean, default: false, desc: "Submit the run as a job to the space-server's queue instead of running locally (sandboxed executor; requires --host/--token/--backend-url)"
-        option   :host,        default: nil, desc: "Base URL of the space-server (required with --as-job)"
-        option   :token,       default: nil, desc: "Bearer token for authorization (required with --as-job)"
-        option   :backend_url, default: nil, desc: "Base URL of the harness backend the sandboxed job talks to (required with --as-job)"
-        option   :job_model,   default: nil, desc: "Model pinned for the sandboxed job's harness — distinct from --model, which is meaningless against a non-Anthropic backend"
-        option   :api_key_ref, default: nil, desc: "op:// reference resolved into ANTHROPIC_API_KEY server-side (--as-job only; omit for keyless backends)"
 
         def call(iteration:, lane:, space: nil, prompt: nil, model: nil,
                  max_turns: "200", harness: nil, effort: nil, thinking: nil, reasoning: nil,
-                 allowed_tools: nil, append_allowed_tools: nil,
                  force_effort: nil, force_thinking: nil, force_reasoning: nil, quiet: false, detach: false,
-                 timeout: "14400", push_url: nil, push_token: nil, push_host: nil,
-                 as_job: false, host: nil, token: nil, backend_url: nil, job_model: nil, api_key_ref: nil, **opts)
+                 timeout: "14400", push_url: nil, push_token: nil, push_host: nil, **opts)
           setup_terminal(**opts.slice(:color, :colors))
           handle_errors do
             level = resolve_thinking_alias(effort: effort, thinking: thinking, reasoning: reasoning)
             forced_level = resolve_force_thinking_alias(force_effort: force_effort,
               force_thinking: force_thinking, force_reasoning: force_reasoning)
 
-            if as_job
-              Jobs.require_credentials!(host, token)
-              raise Space::Core::Error, "--backend-url is required with --as-job" unless backend_url
-              raise Space::Core::Error, "--job-model is required with --as-job" unless job_model
-              raise Space::Core::Error, "--as-job cannot be combined with --push-url/--push-token/--push-host/--detach" \
-                if push_url || push_token || push_host || detach
-            end
-
             render(store.find(space)) do |sp|
               project = ArchitectProject.new(space: sp)
 
-              if as_job
-                kwargs = { host: host, token: token, backend_url: backend_url, max_turns: max_turns.to_i }
-                kwargs[:prompt]      = prompt          if prompt
-                kwargs[:model]       = model           if model
-                kwargs[:harness]     = harness         if harness
-                kwargs[:effort]      = forced_level || level if forced_level || level
-                kwargs[:allowed_tools]        = allowed_tools        if allowed_tools
-                kwargs[:append_allowed_tools] = append_allowed_tools if append_allowed_tools
-                kwargs[:force]       = true            if forced_level
-                kwargs[:quiet]       = true             if quiet
-                kwargs[:job_model]   = job_model       if job_model
-                kwargs[:api_key_ref] = api_key_ref     if api_key_ref
-                res = project.dispatch_as_job(iteration, lane, **kwargs)
-                terminal.say "Prompt:  #{prompt} → #{terminal.path(res[:prompt_copied])}" if res[:prompt_copied]
-                terminal.say "Job:     #{res[:job_id]}"
-                terminal.say "Watch:   architect jobs watch #{res[:job_id]} --host #{host} --token #{token}"
+              kwargs = { max_turns: max_turns.to_i, detach: detach }
+              kwargs[:prompt]     = prompt          if prompt
+              kwargs[:model]      = model           if model
+              kwargs[:harness]    = harness         if harness
+              kwargs[:effort]     = forced_level || level if forced_level || level
+              kwargs[:force]      = true            if forced_level
+              kwargs[:quiet]      = true             if quiet
+              kwargs[:timeout]    = timeout.to_i    unless detach
+              kwargs[:push_url]   = push_url        if push_url
+              kwargs[:push_token] = push_token      if push_token
+              kwargs[:push_host]  = push_host       if push_host
+              res = project.dispatch(iteration, lane, **kwargs)
+              terminal.say "Prompt:  #{prompt} → #{terminal.path(res[:prompt_copied])}" if res[:prompt_copied]
+              if detach
+                terminal.say "PID:     #{res[:pid]}"
+                terminal.say "Run log: #{terminal.path(res[:run_log])}"
+                terminal.say "Report:  #{terminal.path(res[:report])}"
+                terminal.say "Dispatched detached — poll #{terminal.path(res[:report])} for completion"
                 CLI.record_outcome(Outcome.new(exit_code: 0))
+              elsif res[:timed_out]
+                terminal.say "Run log: #{terminal.path(res[:run_log])}"
+                terminal.say "Report:  #{terminal.path(res[:report])}"
+                terminal.say "Builder TIMED OUT after #{timeout}s — process group killed. Re-dispatch (lanes are cheap)."
+                CLI.record_outcome(Outcome.new(exit_code: res[:exit_code]))
               else
-                kwargs = { max_turns: max_turns.to_i, detach: detach }
-                kwargs[:prompt]     = prompt          if prompt
-                kwargs[:model]      = model           if model
-                kwargs[:harness]    = harness         if harness
-                kwargs[:effort]     = forced_level || level if forced_level || level
-                kwargs[:allowed_tools]        = allowed_tools        if allowed_tools
-                kwargs[:append_allowed_tools] = append_allowed_tools if append_allowed_tools
-                kwargs[:force]      = true            if forced_level
-                kwargs[:quiet]      = true             if quiet
-                kwargs[:timeout]    = timeout.to_i    unless detach
-                kwargs[:push_url]   = push_url        if push_url
-                kwargs[:push_token] = push_token      if push_token
-                kwargs[:push_host]  = push_host       if push_host
-                res = project.dispatch(iteration, lane, **kwargs)
-                terminal.say "Prompt:  #{prompt} → #{terminal.path(res[:prompt_copied])}" if res[:prompt_copied]
-                if detach
-                  terminal.say "PID:     #{res[:pid]}"
-                  terminal.say "Run log: #{terminal.path(res[:run_log])}"
-                  terminal.say "Report:  #{terminal.path(res[:report])}"
-                  terminal.say "Dispatched detached — poll #{terminal.path(res[:report])} for completion"
-                  CLI.record_outcome(Outcome.new(exit_code: 0))
-                elsif res[:timed_out]
-                  terminal.say "Run log: #{terminal.path(res[:run_log])}"
-                  terminal.say "Report:  #{terminal.path(res[:report])}"
-                  terminal.say "Builder TIMED OUT after #{timeout}s — process group killed. Re-dispatch (lanes are cheap)."
-                  CLI.record_outcome(Outcome.new(exit_code: res[:exit_code]))
-                else
-                  terminal.say "Run log: #{terminal.path(res[:run_log])}"
-                  terminal.say "Report:  #{terminal.path(res[:report])}"
-                  terminal.say "Ingest URL:  #{res[:push_url]}" if res[:push_url]
-                  terminal.say "Builder exited with status #{res[:exit_code]}"
-                  unless res[:report].exist? && !res[:report].read.strip.empty?
-                    terminal.say "WARNING: no report at #{terminal.path(res[:report])} — the lane produced no deliverable."
-                  end
-                  CLI.record_outcome(Outcome.new(exit_code: res[:exit_code]))
+                terminal.say "Run log: #{terminal.path(res[:run_log])}"
+                terminal.say "Report:  #{terminal.path(res[:report])}"
+                terminal.say "Ingest URL:  #{res[:push_url]}" if res[:push_url]
+                terminal.say "Builder exited with status #{res[:exit_code]}"
+                unless res[:report].exist? && !res[:report].read.strip.empty?
+                  terminal.say "WARNING: no report at #{terminal.path(res[:report])} — the lane produced no deliverable."
                 end
+                CLI.record_outcome(Outcome.new(exit_code: res[:exit_code]))
               end
             end
           end
@@ -847,7 +799,8 @@ module Space::Architect
             terminal.say result[:command]
             terminal.say ""
             terminal.say "Diagnostics:"
-            terminal.say "  space-architect #{Space::Core::VERSION}"
+            terminal.say "  space-architect #{Space::Architect::VERSION}"
+            terminal.say "  space-cadet #{Space::Core::VERSION}"
             terminal.say "  ruby #{RUBY_VERSION} (#{RUBY_PLATFORM})"
             terminal.say "  space: #{space.id} — #{space.title}" if space
             CLI.record_outcome(Outcome.new(exit_code: 0))
@@ -858,7 +811,7 @@ module Space::Architect
       class InstallSkills < BaseCommand
         desc "Install bundled skills (architect, architect-research, architect-vocabulary) for a harness"
         phase 53, "Project"
-        option :provider, default: "claude", desc: "Harness: claude, codex, opencode, pi"
+        option :provider, default: "claude", desc: "Skill install target (default: claude; validated by the installer)"
         option :project, type: :boolean, default: false, desc: "Install to CWD instead of global"
         option :force,   type: :boolean, default: false, desc: "Overwrite existing skills that differ"
         option :dry_run, type: :boolean, default: false, desc: "Print what would happen without writing files"
@@ -886,11 +839,11 @@ module Space::Architect
           argument :lane,      required: true, desc: "Lane name"
           argument :space,     required: false, desc: "Space identifier (default: $PWD)"
           option   :base,      default: nil,          desc: "Base ref (default: HEAD of repo)"
-          option   :harness,   default: nil,          desc: "Harness (claude-code, opencode, pi; default: space.yaml project.harness, else claude-code)"
-          option   :model,     default: nil,           desc: "Model; a trailing :<level> suffix (e.g. foo:high) is parsed into --effort (default: space.yaml project.model, else the per-harness sensible default)"
-          option   :effort,    default: nil,           desc: "Thinking/reasoning effort level — alias for --thinking/--reasoning (off, minimal, low, medium, high, xhigh, max); translated + clamped to the lane's harness at dispatch time"
-          option   :thinking,  default: nil,           desc: "Thinking/reasoning effort level — alias for --effort/--reasoning (off, minimal, low, medium, high, xhigh, max); translated + clamped to the lane's harness at dispatch time"
-          option   :reasoning, default: nil,           desc: "Thinking/reasoning effort level — alias for --effort/--thinking (off, minimal, low, medium, high, xhigh, max); translated + clamped to the lane's harness at dispatch time"
+          option   :harness,   default: nil,          desc: "Harness (pi; default: space.yaml project.harness, else pi)"
+          option   :model,     default: nil,           desc: "Model; a trailing :<level> suffix (e.g. foo:high) is parsed into --effort (default: space.yaml project.model, else the pi default #{Harness::DEFAULT_MODEL})"
+          option   :effort,    default: nil,           desc: "Thinking/reasoning effort level — alias for --thinking/--reasoning (off, minimal, low, medium, high, xhigh, max)"
+          option   :thinking,  default: nil,           desc: "Thinking/reasoning effort level — alias for --effort/--reasoning (off, minimal, low, medium, high, xhigh, max)"
+          option   :reasoning, default: nil,           desc: "Thinking/reasoning effort level — alias for --effort/--thinking (off, minimal, low, medium, high, xhigh, max)"
           option   :quiet,     type: :boolean, default: false, desc: "Suppress the thinking-translation inform line on $stderr"
           option   :touch,     default: nil,           desc: "Comma-separated file globs the lane may touch (records its touch_set for in-bounds + merge checks)"
           option   :force,     type: :boolean, default: false, desc: "Clear and re-create a stale (unregistered) worktree directory"
@@ -970,7 +923,7 @@ module Space::Architect
           argument :repo,      required: true,  desc: "Repo name (under repos/)"
           argument :iteration, required: true,  desc: "Iteration name"
           argument :space,     required: false, desc: "Space identifier (default: $PWD)"
-          option   :pairs,     required: true,  desc: "Comma-separated harness[:model] pairs (e.g. claude-code,opencode:fireworks-ai/accounts/fireworks/models/glm-5p2)"
+          option   :pairs,     required: true,  desc: "Comma-separated harness[:model] pairs (e.g. pi,pi:#{Harness::DEFAULT_MODEL})"
           option   :base,      default: nil,    desc: "Base ref (default: HEAD of repo)"
           option   :prompt,    default: nil,    desc: "Prompt file to fan-out byte-identical to each variant"
 
@@ -1215,6 +1168,17 @@ module Space::Architect
             end
 
             def format_failure(f) = f.is_a?(Hash) ? f.inspect : f.to_s
+
+            # The launchd-agent seam is repo-tender's — a soft dependency, never a
+            # gemspec runtime dep. Required lazily so `sessions agent …` degrades
+            # with an actionable hint instead of failing at boot when the gem is
+            # absent; handle_errors turns the raise into a red message + exit 1.
+            def agent
+              require "repo_tender"
+              RepoTender::Launchd::Agent
+            rescue LoadError
+              raise Space::Core::Error, "sessions agent needs the repo-tender gem — install it with: gem install repo-tender"
+            end
           end
 
           class Install < BaseCommand
@@ -1243,7 +1207,7 @@ module Space::Architect
                 File.write(pp, xml)
                 File.chmod(0o600, pp)
 
-                result = Space::Src::Launchd::Agent.new(label: SessionSync::LABEL).install(pp)
+                result = agent.new(label: SessionSync::LABEL).install(pp)
                 raise Space::Core::Error, "bootstrap failed: #{format_failure(result.failure)}" if result.failure?
 
                 terminal.say "Installed: #{terminal.path(pp)}"
@@ -1260,7 +1224,7 @@ module Space::Architect
               setup_terminal(**opts.slice(:color, :colors))
               handle_errors do
                 pp = plist_path
-                result = Space::Src::Launchd::Agent.new(label: SessionSync::LABEL).uninstall
+                result = agent.new(label: SessionSync::LABEL).uninstall
                 terminal.say "bootout reported: #{format_failure(result.failure)}" if result.failure?
 
                 if File.exist?(pp)
@@ -1281,7 +1245,7 @@ module Space::Architect
             def call(**opts)
               setup_terminal(**opts.slice(:color, :colors))
               handle_errors do
-                result = Space::Src::Launchd::Agent.new(label: SessionSync::LABEL).status
+                result = agent.new(label: SessionSync::LABEL).status
                 raise Space::Core::Error, "status failed: #{format_failure(result.failure)}" if result.failure?
 
                 s = result.success
@@ -1303,6 +1267,8 @@ end
 # Loop-phase declarations above sort the architect help listing; its namespaces
 # (brief/worktree/variant/research) declare no phase and list under this header.
 Space::Core::CLI::Help.trailing_group_label = "Groups"
+Space::Core::CLI::Help.product_name = "architect"
+Space::Core::CLI::Help.product_version = Space::Architect::VERSION
 
 Space::Architect::CLI::Registry.register "init",   Space::Architect::CLI::Architect::Init
 Space::Architect::CLI::Registry.register "ground", Space::Architect::CLI::Architect::Ground

data/lib/space_architect/cli/research.rb

@@ -8,7 +8,7 @@ module Space::Architect
           desc "Dispatch detached read-only research lanes (one per prompt file)"
           argument :prompts, type: :array, 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 :model,     default: nil, desc: "Researcher model override (default: the pi default #{Space::Architect::Harness::DEFAULT_MODEL})"
           option :max_turns, default: "40", desc: "Max turns per researcher"
 
           def call(prompts:, model: nil, max_turns: "40", **opts)