space-architect 5.0.0 → 5.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6846eab011f92f0b54a7bb886d7b97cf8c727beb3fc6d279a2db603062645520
-  data.tar.gz: 0bc8f0b22f785fd2d3ed77419a1ad3b6058e4b76a6aaee41b7a66793b865702a
+  metadata.gz: 3e8120606794bd415a99f1fffa4f850a141aeb0674a94b809311c19513e2bef3
+  data.tar.gz: 45796109310f890c1e20c13cd01c42bc09d88dbd3cb0dd8fb8b3dbb73cad8c0b
 SHA512:
-  metadata.gz: 77216fd23779d4ee5ae16f3c141fc9f7670b3efc3c8b7fe31292c31284be0903616505c4199fbe4e5d7b12988d0638e7a31cba600a4625caad2b939255fc9370
-  data.tar.gz: ca1fb9e9bd1c20c6ef201d60f763cdcb87b18b9c289169ff601be6c858b0558f283986b2b24bb82cf73b4b1001c3ce0a9955bd02675557548fcc2e930aea27d2
+  metadata.gz: 9cd1e6c226adfce0082aeee3aea0b9f7e24dbcbd583ab8ce715c79ed2e9352baf4274922c241f7f25599f42bcee044ba878aa622555e4c813928bbf26038985b
+  data.tar.gz: 3ea9beaa3bce9a280893b5d2d1021dfe050285e6584d9ff42d010548eeb955ddede01f286251ddec3a966b679dab650be129a4cbac36a666cdbe3d8966a3ac7b

data/CHANGELOG.md

@@ -5,6 +5,120 @@ 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
+
+- **`architect integrate --into <branch>`** — merge a lane into a named branch
+  instead of the slug-derived `project/<slug>` default (#47). Outside-touch-set
+  conflict message gains an `--into` hint; inside-touch conflict keeps "spec
+  defect".
+- **Conductor commit-mode** — `commit_mode: conductor` in `space.yaml` plus a
+  `--commit-mode` CLI flag on `verify`/`integrate`: canonical conductor commits
+  are classified as non-builder in the lane mechanical check, with canonical
+  message-shape matching (#55).
+- **`architect sync` subcommand** (`--ff-only`, per-repo status) plus a
+  `ground` stale-repo WARNING with behind count and `--into` hint. **No
+  auto-sync** — the operator runs `sync` (#49).
+- **`architect freeze --force` / `section --force`** — re-freeze an iteration
+  whose frozen region changed since the last freeze, or write a frozen section
+  after the freeze (pre-dispatch amend paths). Both refuse if any lane has
+  `dispatched_at` OR `integrate_sha` — moving `freeze_sha` or rewriting a frozen
+  section after a builder has run against the AC breaks the cardinal invariant
+  (AC freeze before results exist; judging quotes the freeze commit). The guard
+  names the offending lane and the reason.
+- **`architect merge --into <branch>` / `--commit-mode <mode>`** — wires the
+  existing `merge_lane!` `into:`/`commit_mode:` kwargs through the `Merge` CLI,
+  matching `Integrate`'s surface.
+- **`architect provision --force` / `worktree add --force`** — `worktree_add`
+  gains a `force: false` kwarg. When a worktree dir exists but is unknown to git
+  (stale, e.g. left by an aborted provision), `force: true` clears it via
+  `FileUtils.rm_rf` and re-creates; without `force` it still raises with a
+  `--force` hint so a genuine git-tracked dir is never silently destroyed.
+  `ensure_lane_materialized` (the auto-recovery path) stays non-force —
+  auto-recovery never silently `rm -rf`s; only an explicit operator `--force`.
+
+### Changed
+
+- **`dir/**` in-bounds touch glob is now recursive** — matches
+  `Dir.glob('**/**')` semantics; single-star `*` stays non-recursive.
+  Deep-globbed files inside a lane's declared touch set are in-bounds; outside
+  is still a spec defect (#52, #54).
+- **`dispatched_at` recorded in `space.yaml` at dispatch time** (#18).
+
+### Fixed
+
+- **Canonical `section`/`freeze` commit message shape** — per-section commits
+  and the freeze commit carry the correct canonical prefix and body.
+- **`space run --help` steers to the `--` separator** — a quoted multi-word
+  command otherwise arrives as one argv token → opaque in-guest failure; the
+  desc/argument/example now show the `--` form, with a subprocess test (#28).
+- **Dropped a load-time "assigned but unused variable" warning** — `build_dir`
+  in `worktree_add` was computed but never read.
+
 ## [5.0.0] - 2026-07-06
 
 ### Added

data/lib/space_architect/architect_project.rb

@@ -20,13 +20,13 @@ module Space::Architect
     FROZEN_BOUNDARY = /^## Builder Prompt/
 
     # Sections the architect writes (and the CLI commits) via `architect section`.
-    # Acceptance Criteria is intentionally absent — it is set by `architect freeze`,
-    # the one code path that creates the freeze commit. Builder Report has its own
-    # command (`architect evidence`) because it is transcribed verbatim from scratch.
+    # Builder Report has its own command (`architect evidence`) because it is
+    # transcribed verbatim from scratch.
     # `frozen: true` sections live above the freeze boundary and are refused once frozen.
     SECTIONS = {
       "grounds" => { heading: "## Grounds", message: "grounds", prefix: "grounds", frozen: true },
       "specification" => { heading: "## Specification", message: "specification", prefix: "spec", frozen: true },
+      "acceptance-criteria" => { heading: "## Acceptance Criteria", message: "acceptance criteria", prefix: "ac", frozen: true },
       "prompt" => { heading: "## Builder Prompt", message: "dispatched", prefix: "prompt", frozen: false },
       "verdict" => { heading: "## Verdict", message: "verdict", prefix: "verdict", frozen: false }
     }.freeze
@@ -158,7 +158,8 @@ module Space::Architect
     # Freeze the iteration: the iteration file must carry a "## Acceptance Criteria" section. Commits
     # any pending changes to the iteration file and records HEAD as freeze_sha. If
     # already frozen, refuses when the frozen region has changed since.
-    def freeze!(iteration, warnings: nil, message: nil)
+    # With force: true, re-freezes a changed frozen region if no lane is dispatched yet.
+    def freeze!(iteration, warnings: nil, message: nil, force: false)
       entry = slice_entry(iteration)
       rel = entry["file"]
       path = space.path.join(rel)
@@ -174,11 +175,17 @@ module Space::Architect
       if entry["freeze_sha"]
         sha = entry["freeze_sha"]
         if frozen_region_changed?(sha, rel)
-          raise Space::Core::Error,
-            "Frozen sections of #{rel} changed since freeze #{sha[0, 8]} — " \
-            "refusing to re-freeze. Restore them to their frozen state or use a new iteration."
+          if force
+            dispatched_guard!(entry)
+            # fall through to commit path to re-freeze with new sha
+          else
+            raise Space::Core::Error,
+              "Frozen sections of #{rel} changed since freeze #{sha[0, 8]} — " \
+              "refusing to re-freeze. Restore them to their frozen state or use a new iteration."
+          end
+        else
+          return sha
         end
-        return sha
       end
 
       files = [rel]
@@ -208,6 +215,9 @@ module Space::Architect
         b
       end
 
+      git_run("-C", space.path.to_s, "commit", "-m",
+        compose_message("I#{nn} freeze:", "I#{nn}: record freeze sha", message), "--", Space::Core::Space::METADATA_FILE)
+
       sha
     end
 
@@ -232,14 +242,15 @@ module Space::Architect
 
     # Write one section of the iteration file and commit it with the canonical
     # per-section message, in one call. Refuses to write a frozen section
-    # (Grounds/Specification) once the iteration is frozen. Acceptance Criteria is
-    # NOT writable here (use freeze); Builder Report is not here (use evidence).
-    def write_section!(iteration, section, body:, append: false, lane: nil, message: nil)
+    # (Grounds/Specification/Acceptance Criteria) once the iteration is frozen.
+    # With force: true, writes a frozen section if no lane is dispatched yet.
+    # Builder Report is not here (use evidence).
+    def write_section!(iteration, section, body:, append: false, lane: nil, message: nil, force: false)
       spec = SECTIONS[section]
       unless spec
         raise Space::Core::Error,
           "Unknown section '#{section}' — one of: #{SECTIONS.keys.join(', ')}. " \
-          "(Acceptance Criteria is set by `architect freeze`; Builder Report by `architect evidence`.)"
+          "(Builder Report is written by `architect evidence`.)"
       end
 
       entry = slice_entry(iteration)
@@ -248,13 +259,19 @@ module Space::Architect
       raise Space::Core::Error, "#{rel} does not exist — run `architect new #{iteration}` first" unless path.exist?
 
       if spec[:frozen] && entry["freeze_sha"]
-        raise Space::Core::Error,
-          "#{spec[:heading]} is frozen for #{iteration} (freeze #{entry["freeze_sha"][0, 8]}) — " \
-          "frozen sections are read-only after the freeze commit. Open a new iteration to change the contract."
+        if force
+          dispatched_guard!(entry)
+        else
+          raise Space::Core::Error,
+            "#{spec[:heading]} is frozen for #{iteration} (freeze #{entry["freeze_sha"][0, 8]}) — " \
+            "frozen sections are read-only after the freeze commit. Open a new iteration to change the contract."
+        end
       end
 
       block = lane ? "### #{lane}\n\n#{body.strip}" : body.strip
-      path.write(replace_section_body(path.read, spec[:heading], block, append: append))
+      new_text = replace_section_body(path.read, spec[:heading], block, append: append)
+      lint_gates!(new_text) if section == "acceptance-criteria"
+      path.write(new_text)
 
       nn = format("%02d", entry["ordinal"] || 0)
       _o, _e, cst = git_capture("-C", space.path.to_s, "commit", "-m",
@@ -342,13 +359,13 @@ module Space::Architect
     # the lane branch, then merge --no-ff into the repo's lane/<id> integration branch.
     # Runs NO gates and makes NO pass/fail decision. Refuses a mechanically-failing lane
     # (builder commits / out-of-bounds) and aborts cleanly on a merge conflict.
-    def merge_lane!(iteration, lane, message: nil)
+    def merge_lane!(iteration, lane, message: nil, commit_mode: nil, into: nil)
       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)
 
-      checks = lane_mechanical_checks(entry, lane_entry)
+      checks = lane_mechanical_checks(entry, lane_entry, commit_mode: commit_mode)
       if checks[:no_builder_commits] == false
         raise Space::Core::Error, "Lane '#{lane}' has builder commits — the worktree is tampered (hard rule 7). Reset and re-dispatch; do not merge."
       end
@@ -363,7 +380,7 @@ module Space::Architect
       raise Space::Core::Error, "Worktree directory does not exist: #{wt_path}" unless wt_path.exist?
       base_sha = lane_entry["base_sha"]
       lane_branch = "lane/#{id}-#{lane}"
-      integration_branch = project_integration_branch
+      integration_branch = into || project_integration_branch
 
       status_out, = git_capture("-C", wt_path.to_s, "status", "--porcelain")
       raise Space::Core::Error, "Lane '#{lane}' worktree has no changes to integrate." if status_out.strip.empty?
@@ -385,9 +402,22 @@ module Space::Architect
       unless mst.success?
         conflicts, = git_capture("-C", repo_path.to_s, "diff", "--name-only", "--diff-filter=U")
         git_capture("-C", repo_path.to_s, "merge", "--abort")
-        raise Space::Core::Error,
-          "Merge conflict integrating lane '#{lane}' (#{conflicts.split.join(", ")}) — the lane plan was " \
-          "not disjoint = a spec defect. Kill the conflicting lane and re-spec; do not hand-resolve. #{merr.strip}"
+        conflict_files = conflicts.split
+        lane_touch_set = lane_entry["touch_set"] || []
+        fnm = File::FNM_PATHNAME | File::FNM_EXTGLOB
+        outside = conflict_files.reject do |f|
+          lane_touch_set.any? { |g| File.fnmatch(g, f, fnm) || (g.end_with?("/**") && File.fnmatch("#{g}/*", f, fnm)) }
+        end
+        if !lane_touch_set.empty? && outside.empty?
+          raise Space::Core::Error,
+            "Merge conflict integrating lane '#{lane}' (#{conflict_files.join(", ")}) — the lane plan was " \
+            "not disjoint = a spec defect. Kill the conflicting lane and re-spec; do not hand-resolve. #{merr.strip}"
+        else
+          raise Space::Core::Error,
+            "Merge conflict integrating lane '#{lane}' (#{conflict_files.join(", ")}) — conflicting files " \
+            "are outside the lane's touch set; this looks like a branch mismatch: the lane is being merged " \
+            "into '#{integration_branch}'. Use --into <branch> to target the correct branch. #{merr.strip}"
+        end
       end
 
       merge_sha, = git_capture("-C", repo_path.to_s, "rev-parse", "HEAD")
@@ -414,14 +444,14 @@ module Space::Architect
     # first conflict (a disjointness defect). Never decides which lanes pass. With no
     # lanes and teardown: true, tears down every lane recorded for the iteration instead
     # (the second, teardown-only call in the loop's integrate-then-teardown rhythm).
-    def integrate!(iteration, lanes: nil, teardown: false, message: nil)
+    def integrate!(iteration, lanes: nil, teardown: false, message: nil, commit_mode: nil, into: nil)
       lanes = Array(lanes)
       return teardown_lanes!(iteration, slice_entry(iteration)["lanes"] || []) if lanes.empty? && teardown
       raise Space::Core::Error, "No lanes given to integrate" if lanes.empty?
 
       merged = []
       lanes.each do |lane|
-        merged << merge_lane!(iteration, lane, message: message)
+        merged << merge_lane!(iteration, lane, message: message, commit_mode: commit_mode, into: into)
       rescue Space::Core::Error => e
         done = merged.map { |m| m[:lane] }.join(", ")
         raise Space::Core::Error, "Integrated #{done.empty? ? "(none)" : done} then stopped at '#{lane}': #{e.message}"
@@ -534,20 +564,53 @@ module Space::Architect
         parts << "=== #{rel} ===\n\n#{iter_path.read}"
       end
 
+      space.repos.each do |repo|
+        name      = repo["name"]
+        repo_path = space.path.join("repos", name).to_s
+        next unless Dir.exist?(repo_path)
+
+        branch_out, _, branch_st = git_capture("-C", repo_path, "symbolic-ref", "--short", "HEAD")
+        next unless branch_st.success?
+        branch = branch_out.strip
+
+        git_capture("-C", repo_path, "fetch", "origin")
+
+        count_out, _, count_st = git_capture("-C", repo_path, "rev-list", "--left-right", "--count",
+          "#{branch}...origin/#{branch}")
+        next unless count_st.success?
+
+        behind = count_out.strip.split[1].to_i
+        if behind > 0
+          parts << "WARNING: repos/#{name} local #{branch} is #{behind} commits behind " \
+            "origin/#{branch} — run `architect sync #{name}`"
+        end
+      rescue
+        # tolerate fetch or comparison failures silently
+      end
+
       parts.join("\n")
     end
 
-    def worktree_add(repo, iteration, lane, base: nil, harness: "claude-code", model: nil, variant: false, effort: nil, touch: nil)
-      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)"
+    # Sync tracked repo clones with their remotes (fast-forward only).
+    # Returns an array of result hashes: { repo:, status:, message: }.
+    # With no repo_name, syncs every tracked repo; with a name, syncs only that one.
+    def sync_repos(repo_name: nil)
+      repos = space.repos
+      if repo_name
+        repos = repos.select { |r| r["name"] == repo_name }
+        raise Space::Core::Error, "repo '#{repo_name}' not tracked in this space" if repos.empty?
       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)"
+      repos.map { |r| sync_one_repo(r["name"]) }
+    end
+
+    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)
@@ -556,7 +619,6 @@ module Space::Architect
 
       id = iteration_id(entry)
       wt_path   = space.path.join("build", "#{id}-#{lane}", "wt")
-      build_dir = space.path.join("build", "#{id}-#{lane}")
       FileUtils.mkdir_p(wt_path.dirname)
 
       base_ref = base || "HEAD"
@@ -566,11 +628,15 @@ module Space::Architect
 
       branch = "lane/#{id}-#{lane}"
 
-      # Guard: an existing directory that is not a registered worktree is ambiguous — refuse.
+      # Guard: an existing directory that is not a registered worktree is ambiguous.
       if wt_path.exist? && !worktree_registered?(repo_path, wt_path)
-        raise Space::Core::Error,
-          "#{wt_path} exists but is not a registered git worktree of #{repo} — " \
-          "resolve manually before re-running worktree_add"
+        if force
+          FileUtils.rm_rf(wt_path)
+        else
+          raise Space::Core::Error,
+            "#{wt_path} exists but is not a registered git worktree of #{repo} — " \
+            "resolve manually before re-running worktree_add, or re-run with --force to clear and re-create it"
+        end
       end
 
       # Skip git worktree add when the branch and worktree already exist (idempotent re-run).
@@ -594,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|
@@ -727,7 +793,7 @@ module Space::Architect
     # record worktree/base_sha/integration_branch. Idempotent — an already-materialized
     # lane is skipped, not re-created. Refuses until the iteration is frozen, because
     # declarations are not authoritative until then.
-    def provision(iteration, base: nil, lane: nil)
+    def provision(iteration, base: nil, lane: nil, force: false)
       entry = slice_entry(iteration)
       raise Space::Core::Error,
         "Iteration '#{iteration}' is not frozen — freeze before provisioning (declarations are not authoritative until frozen)." \
@@ -745,37 +811,50 @@ module Space::Architect
           { lane: name, worktree: wt_path, base_sha: l["base_sha"], created: false }
         else
           result = worktree_add(l["repo"], iteration, name, base: resolve_lane_base(l["repo"], base),
-                                **recorded_lane_fields(l))
+                                force: force, **recorded_lane_fields(l))
           { lane: name, worktree: result[:worktree], base_sha: result[:base_sha], created: true }
         end
       end
     end
 
-    def verify(iteration)
+    def verify(iteration, commit_mode: nil)
       entry = slice_entry(iteration)
       (entry["lanes"] || []).map do |lane|
         ensure_lane_materialized(iteration, lane["name"])
-        { lane: lane["name"], repo: lane["repo"], checks: lane_mechanical_checks(entry, lane) }
+        { lane: lane["name"], repo: lane["repo"], checks: lane_mechanical_checks(entry, lane, commit_mode: commit_mode) }
       end
     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"
@@ -804,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
@@ -844,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)
 
@@ -981,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",
@@ -1030,7 +1136,7 @@ module Space::Architect
 
     # The four per-lane post-flight checks, shared by `verify` (reports) and
     # `merge_lane!` (refuses on failure) so the two can never drift.
-    def lane_mechanical_checks(entry, lane)
+    def lane_mechanical_checks(entry, lane, commit_mode: nil)
       freeze_sha = entry["freeze_sha"]
       rel = entry["file"]
       lane_name = lane["name"]
@@ -1043,12 +1149,21 @@ module Space::Architect
       # (a) frozen sections of the iteration file untouched since freeze
       checks[:frozen_untouched] = (!frozen_region_changed?(freeze_sha, rel) if freeze_sha && rel)
 
-      # (b) no builder commits in the worktree (the architect's integrate commit is excluded)
-      log_out, = git_capture("-C", wt_path.to_s, "log", "--format=%H", "#{base_sha}..")
-      commit_shas = log_out.strip.split("\n").map(&:strip).reject(&:empty?)
+      # (b) no builder commits in the worktree (the architect's integrate commit is excluded;
+      #     in conductor mode, canonical conductor commits are also excluded)
+      effective_commit_mode = commit_mode || space.data.dig("project", "commit_mode") || "strict"
+      log_out, = git_capture("-C", wt_path.to_s, "log", "--format=%H%x09%s", "#{base_sha}..")
+      commit_entries = log_out.strip.split("\n").filter_map do |line|
+        sha, subject = line.strip.split("\t", 2)
+        { sha: sha, subject: subject.to_s } unless sha.nil? || sha.empty?
+      end
       recorded_integrate = lane["integrate_sha"]&.strip
-      builder_shas = recorded_integrate ? commit_shas.reject { |s| s == recorded_integrate } : commit_shas
-      checks[:no_builder_commits] = builder_shas.empty?
+      canonical_conductor = "#{iteration_id(entry)}-#{lane_name}: builder output"
+      builder_commits = commit_entries.reject do |c|
+        c[:sha] == recorded_integrate ||
+          (effective_commit_mode == "conductor" && c[:subject] == canonical_conductor)
+      end
+      checks[:no_builder_commits] = builder_commits.empty?
 
       # (c) builder's scratch report exists and is non-empty
       report = space.path.join("build", "#{iteration_id(entry)}-#{lane_name}", "report.md")
@@ -1059,7 +1174,7 @@ module Space::Architect
         :no_touch_set
       else
         # -z: NUL-delimited; renames emit new_path NUL old_path — include both
-        status_out, = git_capture("-C", wt_path.to_s, "status", "--porcelain", "-z")
+        status_out, = git_capture("-C", wt_path.to_s, "status", "--porcelain", "-z", "-uall")
         changed = []
         entries = status_out.split("\0")
         i = 0
@@ -1076,7 +1191,12 @@ module Space::Architect
           changed << orig if orig && !orig.empty?
         end
         fnm = File::FNM_PATHNAME | File::FNM_EXTGLOB
-        changed.all? { |f| touch_set.any? { |g| File.fnmatch(g, f, fnm) } }
+        changed.all? do |f|
+          touch_set.any? do |g|
+            File.fnmatch(g, f, fnm) ||
+              (g.end_with?("/**") && File.fnmatch("#{g}/*", f, fnm))
+          end
+        end
       end
 
       checks
@@ -1084,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 }
@@ -1093,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
@@ -1190,6 +1316,17 @@ module Space::Architect
       raise Space::Core::Error, "ill-formed gates block:\n#{result.failure.join("\n")}"
     end
 
+    # Raises if any lane in the entry has been dispatched (dispatched_at or integrate_sha set).
+    # Used by freeze! and write_section! --force to prevent rewriting frozen content after a
+    # builder has run (moving freeze_sha post-dispatch breaks the AC cardinal invariant).
+    def dispatched_guard!(entry)
+      lane = (entry["lanes"] || []).find { |l| l["dispatched_at"] || l["integrate_sha"] }
+      return unless lane
+      raise Space::Core::Error,
+        "Lane '#{lane["name"]}' is already dispatched — cannot re-freeze or write frozen sections " \
+        "after dispatch (a builder has run against the frozen AC; rewriting it breaks the cardinal invariant)."
+    end
+
     def staged_changes?
       _o, _e, st = git_capture("-C", space.path.to_s, "diff", "--cached", "--quiet")
       !st.success? # --quiet exits non-zero when there are staged differences
@@ -1235,6 +1372,45 @@ module Space::Architect
       Open3.capture3("git", *args)
     end
 
+    def sync_one_repo(name)
+      repo_path = space.path.join("repos", name).to_s
+
+      dirty_out, _, _ = git_capture("-C", repo_path, "status", "--porcelain")
+      return { repo: name, status: :dirty, message: "#{name}: dirty working tree — skipping" } if dirty_out.strip.length > 0
+
+      branch_out, _, branch_st = git_capture("-C", repo_path, "symbolic-ref", "--short", "HEAD")
+      unless branch_st.success?
+        return { repo: name, status: :error, message: "#{name}: detached HEAD — skipping" }
+      end
+      branch = branch_out.strip
+
+      _, fetch_err, fetch_st = git_capture("-C", repo_path, "fetch", "origin")
+      unless fetch_st.success?
+        return { repo: name, status: :error, message: "#{name}: fetch failed — #{fetch_err.strip}" }
+      end
+
+      count_out, _, count_st = git_capture("-C", repo_path, "rev-list", "--left-right", "--count",
+        "#{branch}...origin/#{branch}")
+      unless count_st.success?
+        return { repo: name, status: :error, message: "#{name}: could not compare with origin/#{branch}" }
+      end
+
+      ahead, behind = count_out.strip.split.map(&:to_i)
+      return { repo: name, status: :up_to_date, message: "#{name}: up to date" } if behind == 0
+
+      if ahead > 0
+        return { repo: name, status: :diverged,
+          message: "#{name}: behind #{behind}, diverged #{ahead} — not fast-forwardable, resolve manually" }
+      end
+
+      _, ff_err, ff_st = git_capture("-C", repo_path, "merge", "--ff-only", "origin/#{branch}")
+      if ff_st.success?
+        { repo: name, status: :fast_forwarded, message: "#{name}: fast-forwarded #{behind} commits" }
+      else
+        { repo: name, status: :ff_failed, message: "#{name}: merge --ff-only failed — #{ff_err.strip}" }
+      end
+    end
+
     def branch_exists?(repo_path, branch)
       _, _, st = git_capture("-C", repo_path.to_s, "rev-parse", "--verify", branch)
       st.success?

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(", ")
@@ -174,20 +202,40 @@ module Space::Architect
         end
       end
 
+      class Sync < BaseCommand
+        desc "Sync tracked repo clones with their remotes (fast-forward only, no rebase/reset)"
+        phase 53, "Project"
+        argument :repo,  required: false, desc: "Repo name to sync (default: all tracked repos)"
+        argument :space, required: false, desc: "Space identifier (default: $PWD)"
+
+        def call(repo: nil, space: nil, **opts)
+          setup_terminal(**opts.slice(:color, :colors))
+          handle_errors do
+            render(store.find(space)) do |sp|
+              project = ArchitectProject.new(space: sp)
+              results = project.sync_repos(repo_name: repo)
+              results.each { |r| terminal.say r[:message] }
+              CLI.record_outcome(Outcome.new(exit_code: 0))
+            end
+          end
+        end
+      end
+
       class Freeze < BaseCommand
         desc "Freeze the iteration's frozen region (Grounds/Specification/Acceptance Criteria) and record the freeze SHA"
         phase 12, "Spec"
         argument :iteration, required: true, desc: "Iteration name"
         argument :space,     required: false, desc: "Space identifier (default: $PWD)"
+        option   :force, type: :boolean, default: false, desc: "Re-freeze even if the frozen region changed (pre-dispatch only)"
         commit_message_options
 
-        def call(iteration:, space: nil, message: nil, message_from: nil, **opts)
+        def call(iteration:, space: nil, message: nil, message_from: nil, force: false, **opts)
           setup_terminal(**opts.slice(:color, :colors))
           handle_errors do
             render(store.find(space)) do |sp|
               project = ArchitectProject.new(space: sp)
               warnings = []
-              sha = project.freeze!(iteration, warnings: warnings,
+              sha = project.freeze!(iteration, warnings: warnings, force: force,
                 message: read_commit_message(message: message, message_from: message_from))
               terminal.say "Frozen #{iteration} at #{sha}"
               warnings.each { |w| terminal.say "Warning: #{w}" }
@@ -206,15 +254,17 @@ module Space::Architect
       class Verify < BaseCommand
         desc "Post-flight mechanical lane checks — frozen-untouched, no builder commits, report exists, in-bounds (reports only, no judgment)"
         phase 30, "Judge"
-        argument :iteration, required: true, desc: "Iteration name"
-        argument :space,     required: false, desc: "Space identifier (default: $PWD)"
+        argument :iteration,   required: true,  desc: "Iteration name"
+        argument :space,       required: false, desc: "Space identifier (default: $PWD)"
+        option   :commit_mode, default: nil,    desc: "Commit mode override (strict|conductor); overrides space.yaml commit_mode for this run"
 
-        def call(iteration:, space: nil, **opts)
+        def call(iteration:, space: nil, commit_mode: nil, **opts)
           setup_terminal(**opts.slice(:color, :colors))
           handle_errors do
             render(store.find(space)) do |sp|
               project = ArchitectProject.new(space: sp)
-              results = project.verify(iteration)
+              terminal.say "Effective commit_mode: #{commit_mode}" if commit_mode
+              results = project.verify(iteration, commit_mode: commit_mode)
 
               if results.empty?
                 terminal.say "No lanes recorded for iteration '#{iteration}'"
@@ -258,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)"
@@ -269,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
@@ -316,13 +379,14 @@ module Space::Architect
         argument :space,     required: false, desc: "Space identifier (default: $PWD)"
         option   :base,      default: nil,    desc: "Base ref override (default: project/<slug> HEAD if it exists, else the repo's default branch)"
         option   :lane,      default: nil,    desc: "Provision only this lane (default: all declared lanes)"
+        option   :force,     type: :boolean, default: false, desc: "Clear and re-create a stale (unregistered) worktree directory"
 
-        def call(iteration:, space: nil, base: nil, lane: nil, **opts)
+        def call(iteration:, space: nil, base: nil, lane: nil, force: false, **opts)
           setup_terminal(**opts.slice(:color, :colors))
           handle_errors do
             render(store.find(space)) do |sp|
               project = ArchitectProject.new(space: sp)
-              results = project.provision(iteration, base: base, lane: lane)
+              results = project.provision(iteration, base: base, lane: lane, force: force)
               if results.empty?
                 terminal.say "No declared lanes to provision for '#{iteration}'"
               else
@@ -341,23 +405,24 @@ module Space::Architect
         desc "Write a section of the iteration file and commit it (one call)"
         phase 11, "Spec"
         argument :iteration, required: true,  desc: "Iteration name"
-        argument :section,   required: true,  desc: "Section: grounds, specification, prompt, verdict"
+        argument :section,   required: true,  desc: "Section: grounds, specification, acceptance-criteria, prompt, verdict"
         argument :space,     required: false, desc: "Space identifier (default: $PWD)"
         option   :from,   default: nil, desc: "Read the section body from this file"
         option   :body,   default: nil, desc: "Inline section body (one-liners)"
         option   :stdin,  type: :boolean, default: false, desc: "Read the section body from stdin"
         option   :append, type: :boolean, default: false, desc: "Append a ### <lane> subsection instead of replacing"
         option   :lane,   default: nil, desc: "Lane name for an appended ### subsection"
+        option   :force,  type: :boolean, default: false, desc: "Write a frozen section (pre-dispatch only)"
         commit_message_options
 
         def call(iteration:, section:, space: nil, from: nil, body: nil, stdin: false, append: false, lane: nil,
-                 message: nil, message_from: nil, **opts)
+                 message: nil, message_from: nil, force: false, **opts)
           setup_terminal(**opts.slice(:color, :colors))
           handle_errors do
             content = read_body(from: from, body: body, stdin: stdin, what: "section body")
             render(store.find(space)) do |sp|
               project = ArchitectProject.new(space: sp)
-              res = project.write_section!(iteration, section, body: content, append: append, lane: lane,
+              res = project.write_section!(iteration, section, body: content, append: append, lane: lane, force: force,
                 message: read_commit_message(message: message, message_from: message_from))
               if res[:committed]
                 terminal.say "Committed #{res[:heading]} → #{res[:sha][0, 8]}"
@@ -425,17 +490,19 @@ module Space::Architect
       class Merge < BaseCommand
         desc "Integrate ONE judged-passing lane (merges --no-ff; runs no gates, makes no verdict)"
         phase 41, "Land"
-        argument :iteration, required: true,  desc: "Iteration name"
-        argument :lane,      required: true,  desc: "Lane name (architect-judged passing)"
-        argument :space,     required: false, desc: "Space identifier (default: $PWD)"
+        argument :iteration,   required: true,  desc: "Iteration name"
+        argument :lane,        required: true,  desc: "Lane name (architect-judged passing)"
+        argument :space,       required: false, desc: "Space identifier (default: $PWD)"
+        option   :into,        required: false, desc: "Merge into this branch instead of the slug-derived project/<slug> default"
+        option   :commit_mode, default: nil,    desc: "Commit mode override (strict|conductor); overrides space.yaml commit_mode for this run"
         commit_message_options
 
-        def call(iteration:, lane:, space: nil, message: nil, message_from: nil, **opts)
+        def call(iteration:, lane:, space: nil, message: nil, message_from: nil, into: nil, commit_mode: nil, **opts)
           setup_terminal(**opts.slice(:color, :colors))
           handle_errors do
             render(store.find(space)) do |sp|
               project = ArchitectProject.new(space: sp)
-              r = project.merge_lane!(iteration, lane,
+              r = project.merge_lane!(iteration, lane, into: into, commit_mode: commit_mode,
                 message: read_commit_message(message: message, message_from: message_from))
               terminal.say "Merged #{lane} → #{r[:integration_branch]} (#{r[:merge_sha][0, 8]})"
               terminal.say r[:diffstat] unless r[:diffstat].empty?
@@ -449,13 +516,15 @@ module Space::Architect
       class Integrate < BaseCommand
         desc "Integrate the architect-supplied set of passing lanes, in order (stops on conflict)"
         phase 40, "Land"
-        argument :iteration, required: true,  desc: "Iteration name"
-        argument :space,     required: false, desc: "Space identifier (default: $PWD)"
-        option   :lanes,     required: false, desc: "Comma-separated passing lane names (you decide the set)"
-        option   :teardown,  type: :boolean, default: false, desc: "Remove worktrees + delete lane branches after merge"
+        argument :iteration,   required: true,  desc: "Iteration name"
+        argument :space,       required: false, desc: "Space identifier (default: $PWD)"
+        option   :lanes,       required: false, desc: "Comma-separated passing lane names (you decide the set)"
+        option   :teardown,    type: :boolean, default: false, desc: "Remove worktrees + delete lane branches after merge"
+        option   :commit_mode, default: nil,    desc: "Commit mode override (strict|conductor); overrides space.yaml commit_mode for this run"
+        option   :into,        required: false, desc: "Merge into this branch instead of the slug-derived project/<slug> default"
         commit_message_options
 
-        def call(iteration:, space: nil, lanes: nil, teardown: false, message: nil, message_from: nil, **opts)
+        def call(iteration:, space: nil, lanes: nil, teardown: false, message: nil, message_from: nil, commit_mode: nil, into: nil, **opts)
           setup_terminal(**opts.slice(:color, :colors))
           handle_errors do
             lane_names = lanes.to_s.split(",").map(&:strip).reject(&:empty?)
@@ -465,7 +534,8 @@ module Space::Architect
             render(store.find(space)) do |sp|
               project = ArchitectProject.new(space: sp)
               results = project.integrate!(iteration, lanes: lane_names, teardown: teardown,
-                message: read_commit_message(message: message, message_from: message_from))
+                message: read_commit_message(message: message, message_from: message_from),
+                commit_mode: commit_mode, into: into)
               if lane_names.empty?
                 if results.empty?
                   terminal.say "Nothing to tear down for #{iteration}"
@@ -570,19 +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, **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)
+                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))
@@ -756,6 +833,7 @@ Space::Architect::CLI::Registry.register "init",   Space::Architect::CLI::Archit
 Space::Architect::CLI::Registry.register "ground", Space::Architect::CLI::Architect::Ground
 Space::Architect::CLI::Registry.register "new",    Space::Architect::CLI::Architect::New
 Space::Architect::CLI::Registry.register "status", Space::Architect::CLI::Architect::Status
+Space::Architect::CLI::Registry.register "sync",   Space::Architect::CLI::Architect::Sync
 Space::Architect::CLI::Registry.register "freeze", Space::Architect::CLI::Architect::Freeze
 Space::Architect::CLI::Registry.register "verify", Space::Architect::CLI::Architect::Verify
 Space::Architect::CLI::Registry.register "provision", Space::Architect::CLI::Architect::Provision

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/cli/run.rb

@@ -5,11 +5,12 @@ require_relative "../oci_runner"
 
 module Space::Core::CLI
 class Run < BaseCommand
-  desc "Run the packed OCI image for the current space (auth injected at runtime)"
+  desc "Run the packed OCI image for the current space (auth injected at runtime). Pass a command and its arguments after `--` so they forward as separate argv tokens"
 
-  argument :command, type: :array, required: false, desc: "Command to run in the container (default: login shell)"
+  argument :command, type: :array, required: false, desc: "Command to run in the container (default: login shell). Use `--` to pass a command with arguments, e.g. `space run -- hermes -z \"hello\"`"
   option :tty, type: :boolean, default: nil, desc: "Force interactive TTY (default: auto-detect)"
   option :env, type: :array, desc: "Host env var to forward into the container (repeatable; adds to run.env)"
+  example "-- hermes -z \"What is 17 plus 4?\"   # `--` forwards the command and its args as separate tokens (a quoted multi-word command arrives as one token and fails in-guest)"
 
   def call(command: [], tty: nil, env: [], **opts)
     setup_terminal(**opts.slice(:color, :colors))

data/lib/space_core/version.rb

@@ -2,6 +2,6 @@
 
 module Space
   module Core
-    VERSION = "5.0.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.0.0
+  version: 5.2.0
 platform: ruby
 authors:
 - Eric Jacobs
@@ -205,6 +205,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: mutant-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement