space-architect 5.1.0 → 5.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09d047544f9e1b3a29c56cc1e982a9624f72d45c2198429fcd7ab4564c31da41'
-  data.tar.gz: ea4e880ceda1c31ba11b390448d2380ca6d45d39394aeef2963c80a0e59a0901
+  metadata.gz: 3e8120606794bd415a99f1fffa4f850a141aeb0674a94b809311c19513e2bef3
+  data.tar.gz: 45796109310f890c1e20c13cd01c42bc09d88dbd3cb0dd8fb8b3dbb73cad8c0b
 SHA512:
-  metadata.gz: 01d09d4cd267afe17f189606d3620bdfa284802c4ccd506a2526172864b85c1124b8096aa3a5ed3fe61cfc3f18929d0aeb8f00d7d9c6238dfdf331ce1e2f8048
-  data.tar.gz: 313a4cf3c9dc69d5cb82d5d8bb1b95fa5d133de711d9ab5e320145525abddff4aebe8fc89cf58e0552d83147fae79ce697b567dce5a8ac387313f5064f58bf2b
+  metadata.gz: 9cd1e6c226adfce0082aeee3aea0b9f7e24dbcbd583ab8ce715c79ed2e9352baf4274922c241f7f25599f42bcee044ba878aa622555e4c813928bbf26038985b
+  data.tar.gz: 3ea9beaa3bce9a280893b5d2d1021dfe050285e6584d9ff42d010548eeb955ddede01f286251ddec3a966b679dab650be129a4cbac36a666cdbe3d8966a3ac7b

data/CHANGELOG.md

@@ -5,6 +5,69 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [5.2.0] - 2026-07-19
+
+### Added
+
+- **`pi` harness (`PiHarness`)** — `pi -p --mode json --model <m> --session-dir
+  <build_dir> --no-approve` as a first-class dispatch harness alongside
+  claude-code and opencode. The session dir is redirected into the lane's
+  `build/` dir via `--session-dir` so nothing leaks to
+  `~/.pi/agent/sessions/`. `when "pi"` factory branch; `dispatch`/
+  `worktree_add` recognize `pi`; CLI descs updated to include `pi`. opencode
+  and claude-code paths byte-for-byte unchanged (I09).
+- **Unified `--effort` / `--thinking` / `--reasoning` knob** — three aliases
+  for one thinking-level setting, normalized to
+  `off, minimal, low, medium, high, xhigh, max`. Per-harness
+  `translate_thinking`: claude `--effort` (low/medium/high/xhigh/max,
+  off→omit, minimal→low); opencode `reasoningEffort` (low/medium/high,
+  xhigh/max→high, off/minimal→omit); pi `--thinking` passthrough (pi's
+  `thinkingLevelMap` clamps, architect doesn't). `--force-{effort,thinking,reasoning}`
+  (dispatch-only) skips the clamp and passes the literal — binary rejection is
+  final. `--quiet` threads a null `err:` sink. A trailing `:level` model-suffix
+  (e.g. `foo:high`) is parsed and translated across all harnesses
+  (explicit > suffix > stored) (I10).
+- **Per-harness sensible model defaults** via `Harness.default_model_for`:
+  `claude-code → claude-sonnet-5`, `pi → qwen3-27b-optiq`,
+  `opencode → fireworks-ai/accounts/fireworks/models/glm-5p2`. The constant
+  `CLAUDE_DEFAULT_MODEL` keeps its name (to avoid a `research/supervisor.rb`
+  ripple) but its value is now `claude-sonnet-5` (I12).
+- **`space.yaml` project defaults** — `project.harness` / `project.model` /
+  `project.effort` (all optional) may be declared in `space.yaml` and sit
+  between the CLI flag and the per-harness default in the resolution chain.
+  Pin a project's harness/model/effort once instead of per command; the user
+  authors them in `space.yaml` directly (no new CLI setter) (I12).
+- **Dispatch stamp** (fixes the `status`-wrong-harness-model bug): `dispatch`
+  now stamps the resolved `harness`/`model`/`effort` onto the lane entry
+  alongside `dispatched_at`, so `architect status` reads what actually ran on
+  the last dispatch — not the `worktree_add`-time values or the global default
+  (I12).
+
+### Changed
+
+- **Shared `resolve_harness_model` helper** DRY across `worktree_add` and
+  `dispatch`. Precedence: explicit CLI flag > lane entry's stored value >
+  `space.yaml` project default > per-harness sensible default. A stored model
+  is only honored when the stored harness still matches the resolved harness,
+  so a `--harness` override drops the old harness's model instead of leaking it
+  (I12).
+- **Section-write idempotence** — `replace_section_body` now strips a leading
+  line equal to the target `## <Heading>` from the supplied body before
+  writing. Makes `architect section <it> <sec>` idempotent: `--from
+  <file-with-heading>` and `--from <body-only>` produce byte-identical output;
+  running it twice never accumulates a duplicate heading. Narrow — only the
+  target heading, so `### fix` sub-headings and wrong-section headings survive
+  (I11).
+
+### Removed
+
+- The `worktree_add` opencode/pi nil-model guards and the factory opencode/pi
+  `model == CLAUDE_DEFAULT_MODEL` guards — per-harness defaults cover nil, and
+  an explicit `--model claude-sonnet-5 --harness pi` is a valid deliberate
+  choice (via openrouter/anthropic routing); the binary rejects an invalid
+  model. Stale "Pass --model" tests rewritten to assert default-resolution
+  (I12).
+
 ## [5.1.0] - 2026-07-19
 
 ### Added

data/lib/space_architect/architect_project.rb

@@ -603,17 +603,14 @@ module Space::Architect
       repos.map { |r| sync_one_repo(r["name"]) }
     end
 
-    def worktree_add(repo, iteration, lane, base: nil, harness: "claude-code", model: nil, variant: false, effort: nil, touch: nil, force: false)
-      if harness.to_s == "opencode" && (model.nil? || model == Harness::CLAUDE_DEFAULT_MODEL)
-        raise Space::Core::Error,
-          "Pass --model when using --harness opencode " \
-          "(#{Harness::CLAUDE_DEFAULT_MODEL} is a Claude model ID, not valid for opencode — " \
-          "try e.g. fireworks-ai/accounts/fireworks/models/glm-5p2)"
-      end
-      if effort && harness.to_s != "opencode"
-        raise Space::Core::Error,
-          "effort is opencode-only (sets opencode reasoningEffort) — " \
-          "set effort only on opencode lanes (harness: opencode)"
+    def worktree_add(repo, iteration, lane, base: nil, harness: nil, model: nil, variant: false,
+                     effort: nil, touch: nil, force: false, err: $stderr)
+      model, suffix_level = Harness.parse_model_suffix(model)
+      harness, model = resolve_harness_model(harness, model)
+      resolved_level = effort || suffix_level || project_defaults["effort"]
+      Harness.validate_thinking_level!(resolved_level)
+      if effort.nil? && suffix_level
+        err.puts "thinking: model suffix ':#{suffix_level}' parsed from lane model → level=#{suffix_level} (model stripped)"
       end
 
       entry = slice_entry(iteration)
@@ -663,7 +660,7 @@ module Space::Architect
         "model" => model,
         "variant" => variant
       }
-      new_fields["effort"]    = effort         if effort
+      new_fields["effort"]    = resolved_level if resolved_level
       new_fields["touch_set"] = Array(touch)   if touch && !Array(touch).empty?
 
       update_architect_block do |b|
@@ -829,22 +826,35 @@ module Space::Architect
     end
 
     def dispatch(iteration, lane, model: nil, max_turns: 200,
-                 claude_bin: nil, harness: nil, opencode_bin: nil, effort: nil, detach: false,
-                 push_url: nil, push_token: nil, push_host: nil, run_creator: nil,
+                 claude_bin: nil, harness: nil, opencode_bin: 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
       raise Space::Core::Error, "--push-host requires --push-token"           if push_host && !push_token
       raise Space::Core::Error, "--detach cannot be combined with --push-url or --push-host" \
         if detach && (push_url || push_host)
 
+      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 = harness || lane_entry["harness"] || "claude-code"
-      resolved_model   = model   || lane_entry["model"]   || Harness::CLAUDE_DEFAULT_MODEL
-      resolved_effort  = effort  || lane_entry["effort"]
+      model, suffix_level = Harness.parse_model_suffix(model)
+      resolved_harness, resolved_model = resolve_harness_model(harness, model,
+        stored_harness: lane_entry["harness"], stored_model: lane_entry["model"])
+
+      resolved_effort =
+        if effort
+          Harness.validate_thinking_level!(effort) unless force
+          effort
+        elsif suffix_level
+          err.puts "thinking: model suffix ':#{suffix_level}' parsed from --model → level=#{suffix_level} (model stripped to '#{model}')"
+          suffix_level
+        else
+          lane_entry["effort"]
+        end
 
       raise Space::Core::Error, "--push-host is only supported with the claude-code harness" \
         if push_host && resolved_harness != "claude-code"
@@ -873,18 +883,23 @@ module Space::Architect
         if prompt_content.empty? || prompt_content == PROMPT_STUB.strip
 
       bin = resolved_harness == "claude-code" ? claude_bin : opencode_bin
-      harness_obj = Harness.for(resolved_harness, model: resolved_model, max_turns: max_turns,
-                                                  bin: bin, config_dir: build_dir, effort: resolved_effort)
-
-      # Stamp launch time 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 value.
+      harness_obj = Harness.for(resolved_harness, model: resolved_model, max_turns: max_turns, bin: bin,
+                                                  config_dir: build_dir, effort: resolved_effort, force: force, err: err)
+
+      # 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.
       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
           end
         end
         b
@@ -913,6 +928,7 @@ module Space::Architect
           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
         exit_code = harness_obj.run(**run_kwargs)
 
@@ -1050,6 +1066,27 @@ module Space::Architect
     # The lane's declared harness/model/variant/effort, as worktree_add kwargs — so a
     # re-materialize preserves them instead of merging back to defaults. touch_set is
     # deliberately omitted: worktree_add leaves it untouched, so it already survives.
+    # The space.yaml project block's optional harness/model/effort defaults (empty
+    # hash when the block or the keys are absent).
+    def project_defaults
+      space.data["project"] || {}
+    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.
+    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
+      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_harness, resolved_model]
+    end
+
     def recorded_lane_fields(lane_entry)
       {
         harness: lane_entry["harness"] || "claude-code",
@@ -1167,7 +1204,10 @@ module Space::Architect
 
     # Replace (or, with append:, extend) the body of a "## Heading" section, leaving
     # every other section byte-untouched. Append replaces a placeholder body (only a
-    # template comment) the first time, then stacks subsections after it.
+    # template comment) the first time, then stacks subsections after it. A supplied
+    # block that redundantly repeats the section's own heading as its first line (the
+    # natural way to author a complete section) has that leading line stripped first,
+    # so writing the same section twice never accumulates a duplicate heading.
     def replace_section_body(text, heading, new_block, append:)
       lines = text.lines
       start = lines.index { |l| l.chomp == heading }
@@ -1176,11 +1216,14 @@ module Space::Architect
       finish = ((start + 1)...lines.length).find { |i| KNOWN_HEADINGS.include?(lines[i].chomp) } || lines.length
       body = lines[(start + 1)...finish].join
 
+      first, rest = new_block.strip.split("\n", 2)
+      block = first == heading ? rest.to_s.strip : new_block.strip
+
       new_body =
         if append && !placeholder_body?(body)
-          "#{body.strip}\n\n#{new_block.strip}"
+          "#{body.strip}\n\n#{block}"
         else
-          new_block.strip
+          block
         end
 
       prefix = lines[0..start].join.rstrip

data/lib/space_architect/cli/architect.rb

@@ -31,7 +31,13 @@ module Space::Architect
       # Authored-content intake shared by section/verdict/brief: a file, an
       # inline flag, or stdin — canonical files are only ever written by the CLI.
       def read_body(from: nil, body: nil, stdin: false, what: "section body")
-        return File.read(from) if from
+        if from
+          begin
+            return File.read(from)
+          rescue Errno::ENOENT
+            raise Space::Core::Error, "file for --from not found: #{from}; provide the #{what} via --from <file>, --body <text>, or --stdin"
+          end
+        end
         return body if body
         return $stdin.read if stdin
 
@@ -41,10 +47,32 @@ module Space::Architect
       # Commit-message intake for commit_message_options: --message-from wins
       # over -m/--message; nil means the command's canonical default message.
       def read_commit_message(message: nil, message_from: nil)
-        return File.read(message_from) if message_from
+        if message_from
+          begin
+            return File.read(message_from)
+          rescue Errno::ENOENT
+            raise Space::Core::Error, "file for --message-from not found: #{message_from}"
+          end
+        end
 
         message
       end
+
+      # --effort/--thinking/--reasoning are three aliases for one thinking-level knob.
+      # At most one may be passed per invocation.
+      def resolve_thinking_alias(effort:, thinking:, reasoning:)
+        given = { effort: effort, thinking: thinking, reasoning: reasoning }.compact
+        raise Space::Core::Error, "pass only one of --effort/--thinking/--reasoning" if given.size > 1
+        given.values.first
+      end
+
+      # --force-effort/--force-thinking/--force-reasoning are three aliases for the
+      # force escape hatch. At most one may be passed per invocation.
+      def resolve_force_thinking_alias(force_effort:, force_thinking:, force_reasoning:)
+        given = { force_effort: force_effort, force_thinking: force_thinking, force_reasoning: force_reasoning }.compact
+        raise Space::Core::Error, "pass only one of --force-effort/--force-thinking/--force-reasoning" if given.size > 1
+        given.values.first
+      end
     end
 
     module Architect
@@ -146,7 +174,7 @@ module Space::Architect
                   lane_list = s["lanes"] || []
                   lanes_str = lane_list.map do |l|
                     h = l["harness"] || "claude-code"
-                    m = l["model"]   || Harness::CLAUDE_DEFAULT_MODEL
+                    m = l["model"]   || Harness.default_model_for(h)
                     eff = l["effort"] ? "·#{l['effort']}" : ""
                     "#{l['name']}(#{l['repo']}·#{h}·#{m}#{eff})"
                   end.join(", ")
@@ -280,10 +308,16 @@ 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 model, else the reference default claude-sonnet-4-6). 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 per-harness sensible default). 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)"
-        option   :effort,    default: nil,    desc: "Reasoning effort override (opencode only; sets reasoningEffort in the model config)"
+        option   :harness,   default: nil,    desc: "Harness override (claude-code, 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   :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)"
@@ -291,17 +325,24 @@ module Space::Architect
         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)"
 
         def call(iteration:, lane:, space: nil, prompt: nil, model: nil,
-                 max_turns: "200", harness: nil, effort: nil, detach: false,
+                 max_turns: "200", harness: nil, effort: nil, thinking: nil, reasoning: 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, **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)
+
             render(store.find(space)) do |sp|
               project = ArchitectProject.new(space: sp)
               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]     = effort          if effort
+              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
@@ -599,20 +640,26 @@ module Space::Architect
           argument :iteration, required: true, desc: "Iteration name"
           argument :lane,      required: true, desc: "Lane name"
           option   :base,      default: nil,          desc: "Base ref (default: HEAD of repo)"
-          option   :harness,   default: "claude-code", desc: "Harness (claude-code, opencode)"
-          option   :model,     default: nil,           desc: "Model (required for opencode)"
-          option   :effort,    default: nil,           desc: "Reasoning effort (opencode only; sets reasoningEffort in the model config)"
+          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   :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"
 
-          def call(repo:, iteration:, lane:, base: nil, harness: "claude-code", model: nil, effort: nil, touch: nil, force: false, **opts)
+          def call(repo:, iteration:, lane:, base: nil, harness: nil, model: nil,
+                   effort: nil, thinking: nil, reasoning: nil, quiet: false, touch: nil, force: false, **opts)
             setup_terminal(**opts.slice(:color, :colors))
             handle_errors do
+              level = resolve_thinking_alias(effort: effort, thinking: thinking, reasoning: reasoning)
               render(store.find) do |sp|
                 project = ArchitectProject.new(space: sp)
                 touch_set = touch ? touch.split(",").map(&:strip).reject(&:empty?) : nil
-                result = project.worktree_add(repo, iteration, lane, base: base,
-                                             harness: harness, model: model, effort: effort, touch: touch_set, force: force)
+                err = quiet ? File.open(File::NULL, "w") : $stderr
+                result = project.worktree_add(repo, iteration, lane, base: base, harness: harness, model: model,
+                                             effort: level, touch: touch_set, force: force, err: err)
                 terminal.say "Worktree: #{terminal.path(result[:worktree])}"
                 terminal.say "Base SHA: #{result[:base_sha]}"
                 CLI.record_outcome(Outcome.new(exit_code: 0))

data/lib/space_architect/harness.rb

@@ -10,30 +10,73 @@ require "uri"
 
 module Space::Architect
   module Harness
-    CLAUDE_DEFAULT_MODEL = "claude-sonnet-4-6"
+    CLAUDE_DEFAULT_MODEL = "claude-sonnet-5"
+
+    # Per-harness sensible default model, used when neither an explicit --model
+    # nor a space.yaml project.model is given.
+    DEFAULT_MODELS = {
+      "claude-code" => CLAUDE_DEFAULT_MODEL,
+      "pi"          => "qwen3-27b-optiq",
+      "opencode"    => "fireworks-ai/accounts/fireworks/models/glm-5p2"
+    }.freeze
+
+    def self.default_model_for(harness_name)
+      DEFAULT_MODELS[harness_name.to_s]
+    end
+
+    # The normalized internal thinking vocabulary — pi's fullest set. Every alias
+    # (--effort/--thinking/--reasoning) is normalized to a member of this array;
+    # each harness then translates + clamps down to its own flag's vocabulary.
+    THINKING_LEVELS = %w[off minimal low medium high xhigh max].freeze
+
+    def self.validate_thinking_level!(level)
+      return if level.nil? || THINKING_LEVELS.include?(level)
+      raise Space::Core::Error,
+        "unknown thinking level '#{level}' — valid: #{THINKING_LEVELS.join(', ')}"
+    end
+
+    # Split a "model:level" id into [model, level] (level nil, model unchanged if no
+    # suffix). Only a trailing segment that is a member of THINKING_LEVELS is treated
+    # as a suffix — a model id containing a literal colon for another reason is left alone.
+    def self.parse_model_suffix(model)
+      return [model, nil] unless model
+      base, _, suffix = model.rpartition(":")
+      return [model, nil] if base.empty? || !THINKING_LEVELS.include?(suffix)
+      [base, suffix]
+    end
 
-    # Factory keyed by harness name.
+    # Per-harness translate + clamp: input a normalized level (or nil) and whether the
+    # caller forced it (skips clamping — the literal is passed through unmodified).
+    # Returns [translated_level_or_nil, inform_line_or_nil].
+    def self.translate_thinking(harness, level, force: false)
+      case harness.to_s
+      when "claude-code" then ClaudeCodeHarness.translate_thinking(level, force: force)
+      when "opencode"    then OpenCodeHarness.translate_thinking(level, force: force)
+      when "pi"          then PiHarness.translate_thinking(level, force: force)
+      else nil
+      end
+    end
+
+    # Factory keyed by harness name. Translates + clamps the normalized `effort`
+    # level to the harness's own vocabulary, printing one inform line to `err`
+    # (default $stderr; thread a null writer to suppress) when it clamps/strips.
+    # With force: true, the literal `effort` value is passed through unmodified.
     # For opencode: config_dir is required (build/<id>-<lane> dir outside the worktree).
-    def self.for(name, model:, max_turns:, bin: nil, config_dir: nil, effort: nil)
+    def self.for(name, model:, max_turns:, bin: nil, config_dir: nil, effort: nil, force: false, err: $stderr)
+      translated, inform = translate_thinking(name, effort, force: force)
+      err.puts(inform) if inform
+
       case name.to_s
       when "claude-code"
-        if effort
-          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)
+        ClaudeCodeHarness.new(model: model, max_turns: max_turns, bin: bin, effort: translated)
       when "opencode"
-        if model == CLAUDE_DEFAULT_MODEL
-          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 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)
+        OpenCodeHarness.new(model: model, max_turns: max_turns, bin: bin, config_dir: config_dir, effort: translated)
+      when "pi"
+        raise Space::Core::Error, "config_dir is required for pi harness" unless config_dir
+        PiHarness.new(model: model, max_turns: max_turns, bin: bin, config_dir: config_dir, effort: translated)
       else
-        raise Space::Core::Error, "Unknown harness '#{name}' — valid values: claude-code, opencode"
+        raise Space::Core::Error, "Unknown harness '#{name}' — valid values: claude-code, opencode, pi"
       end
     end
 
@@ -45,11 +88,27 @@ module Space::Architect
         "Bash(git branch:*)"
       ].join(",")
 
-      def initialize(model:, max_turns:, bin: nil,
+      # claude-code's --effort accepts low/medium/high/xhigh/max; it has no off level
+      # (stripped — omit --effort) and no minimal level (clamped to low).
+      ACCEPTED_LEVELS = %w[low medium high xhigh max].freeze
+      CLAMP_MAP = { "minimal" => "low" }.freeze
+
+      def self.translate_thinking(level, force: false)
+        return [nil, nil] if level.nil?
+        return [level, "thinking: force --effort=#{level} (unmodified, may be rejected)"] if force
+        return [level, nil] if ACCEPTED_LEVELS.include?(level)
+        return [nil, "thinking: off → claude-code (no --effort; claude-code has no off level)"] if level == "off"
+
+        clamped = CLAMP_MAP.fetch(level)
+        [clamped, "thinking: #{level} → claude-code #{clamped} (clamped; claude-code has no #{level} level)"]
+      end
+
+      def initialize(model:, max_turns:, bin: nil, effort: nil,
                      allowed_tools: ALLOWED_TOOLS, disallowed_tools: DISALLOWED_TOOLS)
         @model            = model
         @max_turns        = max_turns
         @bin              = bin || ENV.fetch("ARCHITECT_CLAUDE_BIN", "claude")
+        @effort           = effort
         @allowed_tools    = allowed_tools
         @disallowed_tools = disallowed_tools
       end
@@ -179,6 +238,7 @@ module Space::Architect
           "--max-turns", @max_turns.to_s
         ]
         args += ["--disallowedTools", @disallowed_tools] unless @disallowed_tools.to_s.empty?
+        args += ["--effort", @effort] if @effort
         args
       end
 
@@ -237,6 +297,23 @@ module Space::Architect
     end
 
     class OpenCodeHarness
+      # opencode's reasoningEffort accepts only low/medium/high; off/minimal are
+      # stripped (omit reasoningEffort) and xhigh/max are clamped down to high.
+      ACCEPTED_LEVELS = %w[low medium high].freeze
+      CLAMP_MAP = { "xhigh" => "high", "max" => "high" }.freeze
+
+      def self.translate_thinking(level, force: false)
+        return [nil, nil] if level.nil?
+        return [level, "thinking: force --effort=#{level} (unmodified, may be rejected)"] if force
+        return [level, nil] if ACCEPTED_LEVELS.include?(level)
+
+        if (clamped = CLAMP_MAP[level])
+          [clamped, "thinking: #{level} → opencode #{clamped} (clamped; opencode accepts low/medium/high)"]
+        else
+          [nil, "thinking: #{level} → opencode (omitting reasoningEffort; opencode has no #{level} level)"]
+        end
+      end
+
       def initialize(model:, max_turns:, bin: nil, config_dir:, effort: nil)
         @model      = model
         @max_turns  = max_turns
@@ -346,5 +423,86 @@ module Space::Architect
         args
       end
     end
+
+    # `pi -p --mode json`, session redirected into the lane's build dir via --session-dir
+    # (pi otherwise auto-saves under ~/.pi/agent/sessions/, organized by mangled CWD).
+    class PiHarness
+      TIMEOUT_EXIT_CODE = 124
+
+      # pi's --thinking accepts the full normalized vocabulary unchanged — pi's own
+      # per-model thinkingLevelMap clamps further; architect does not clamp for pi.
+      def self.translate_thinking(level, force: false)
+        return [nil, nil] if level.nil?
+        return [level, "thinking: force --effort=#{level} (unmodified, may be rejected)"] if force
+        [level, nil]
+      end
+
+      # max_turns is accepted for interface parity with the other harnesses but is
+      # intentionally absent from argv — pi has no turn cap; the wall-clock timeout
+      # (below) is the only bound on a run.
+      def initialize(model:, max_turns:, bin: nil, config_dir:, effort: nil)
+        @model      = model
+        @bin        = bin || ENV.fetch("ARCHITECT_PI_BIN", "pi")
+        @config_dir = Pathname.new(config_dir)
+        @effort     = effort
+      end
+
+      def run(prompt_path:, run_log_path:, chdir:, 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|
+            Sync do
+              child = Async::Process::Child.new(*argv, chdir: chdir.to_s, in: prompt_io, out: log, err: log)
+              timed_out    = false
+              timeout_task = nil
+
+              # Same TERM→grace→KILL escalation as ClaudeCodeHarness — with: Async::Process::Child's
+              # #wait_thread ensure goes straight to KILL, so a concurrent fiber does the escalation.
+              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
+
+              timed_out ? TIMEOUT_EXIT_CODE : status.exitstatus
+            end
+          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", "--mode", "json", "--model", @model, "--session-dir", @config_dir.to_s, "--no-approve"]
+        args += ["--thinking", @effort] if @effort
+        args
+      end
+    end
   end
 end

data/lib/space_core/version.rb

@@ -2,6 +2,6 @@
 
 module Space
   module Core
-    VERSION = "5.1.0"
+    VERSION = "5.2.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: space-architect
 version: !ruby/object:Gem::Version
-  version: 5.1.0
+  version: 5.2.0
 platform: ruby
 authors:
 - Eric Jacobs