space-architect 5.5.1 → 7.0.0

data/lib/space_architect/bug_report.rb

@@ -9,20 +9,31 @@ module Space
       REPO = "jetpks/space-architect"
 
       class << self
-        def generate(space: nil, env: ENV, cwd: Dir.pwd, now: Time.now)
+        def generate(space: nil, env: ENV, cwd: Dir.pwd, now: Time.now, title: nil)
           body_path = resolve_body_path(space, cwd, now)
           FileUtils.mkdir_p(body_path.dirname)
-          body = build_body(space)
+          body = build_body(space, title)
           body_path.write(body)
           contracted = Space::Core::Paths.contract(body_path, env: env)
+          title_flag = blank_title?(title) ? "" : " --title #{quote_title(title)}"
           command = Space::Core::Commands.wrap(
-            %(gh issue create -R #{REPO} --title "<one-line summary>" --body-file #{contracted})
+            %(gh issue create -R #{REPO}#{title_flag} --body-file #{contracted})
           )
           { body_path: body_path, command: command, body: body }
         end
 
         private
 
+        # Double-quote a title for a POSIX shell: quotes preserve spaces
+        # literally, only the characters special inside double quotes are escaped.
+        def quote_title(title)
+          %("#{title.gsub(/["\\$`]/) { |m| "\\#{m}" }}")
+        end
+
+        def blank_title?(title)
+          title.to_s.strip.empty?
+        end
+
         def resolve_body_path(space, cwd, now)
           filename = "architect-bug-report-#{now.strftime('%Y%m%d-%H%M%S')}.md"
           if space
@@ -32,8 +43,10 @@ module Space
           end
         end
 
-        def build_body(space)
-          body = +template_header
+        def build_body(space, title)
+          body = +""
+          body << "# #{title}\n\n" unless blank_title?(title)
+          body << template_header
           body << diagnostics_section
           body << space_section(space) if space
           body
@@ -41,8 +54,6 @@ module Space
 
         def template_header
           <<~MD
-            <!-- Title: <one-line summary> -->
-
             **Kind:** <!-- process / tooling / both -->
 
             ## Summary

data/lib/space_architect/cli/architect.rb

@@ -181,7 +181,15 @@ module Space::Architect
                     h = l["harness"] || "claude-code"
                     m = l["model"]   || Harness.default_model_for(h)
                     eff = l["effort"] ? "·#{l['effort']}" : ""
-                    "#{l['name']}(#{l['repo']}·#{h}·#{m}#{eff})"
+                    # #89/AC8: the resolved tool grant, visible next to the other resolved
+                    # values — only when it diverges from the harness default, to keep the
+                    # common case (no lane touches it) uncluttered. Meaningless outside
+                    # claude-code (no equivalent grant mechanism), so shown only there.
+                    tools = if h == "claude-code"
+                      resolved = Harness::ClaudeCodeHarness.resolve_tools(replace: l["allowed_tools"], append: l["append_allowed_tools"])
+                      resolved == Harness::ClaudeCodeHarness::ALLOWED_TOOLS ? "" : "·tools:#{resolved}"
+                    end
+                    "#{l['name']}(#{l['repo']}·#{h}·#{m}#{eff}#{tools})"
                   end.join(", ")
                   lanes = lane_list.any? { |l| l["variant"] } ? "variant: #{lanes_str}" : lanes_str
                   lanes = "#{lanes} → winner: #{s['winner']}" if s["winner"]
@@ -226,23 +234,139 @@ module Space::Architect
         end
       end
 
+      class Rehearse < BaseCommand
+        desc "Rehearse the DRAFTED (unfrozen, working-tree) gates against the repo checkout and report RED/GREEN/BROKEN/EMPTY — runs and reports, never judges"
+        phase 12, "Spec"
+        argument :iteration, required: true,  desc: "Iteration name"
+        argument :space,     required: false, desc: "Space identifier (default: $PWD)"
+        # type: :flag (not :boolean): dry-cli renders a :boolean option as
+        # "--[no-]record" in --help, which does not contain the literal
+        # substring "--record" that a presence-check on the flag would look
+        # for; :flag renders unbracketed ("--record") and is presence-only,
+        # which is all this needs.
+        option   :record, type: :flag, default: false, desc: "Emit a paste-able provenance block summarizing the run, shaped to drop into an Acceptance Criteria preamble"
+
+        def call(iteration:, space: nil, record: false, **opts)
+          setup_terminal(**opts.slice(:color, :colors))
+          handle_errors do
+            render(store.find(space)) do |sp|
+              project = ArchitectProject.new(space: sp)
+              result = project.rehearse(iteration)
+              render_rehearsal(result)
+              terminal.say ""
+              terminal.say render_record(result) if record
+              CLI.record_outcome(Outcome.new(exit_code: 0))
+            end
+          end
+        end
+
+        private
+
+        def render_rehearsal(result)
+          if result[:empty]
+            reason = result[:placeholder] ? "the scaffold placeholder '#{ArchitectProject::AC1_PLACEHOLDER}' with no active gate" : "no gates drafted yet"
+            terminal.say "EMPTY — #{reason}. Nothing to rehearse; the pre-freeze look is still stamped."
+          else
+            terminal.say rehearsal_header(result)
+            result[:gates].each { |g| render_gate(g) }
+            render_scope_asymmetry(result[:scope_asymmetry])
+          end
+          terminal.say ""
+          terminal.say "Discrimination report only — this runs and reports; it never judges whether these gates are good, bad, or ready."
+        end
+
+        # #90/AC7: with a single defaultable repo, name it as before; a cross-repo
+        # run (or one where every gate declares its own `cwd`) has no one repo to
+        # name — each gate's own "dir:" line (below) already says where it ran.
+        def rehearsal_header(result)
+          if result[:repo]
+            "Rehearsing #{result[:iteration]} against #{terminal.path(result[:base_dir])} (repo: #{result[:repo]})"
+          else
+            "Rehearsing #{result[:iteration]} — #{result[:gates].size} gate(s), each in its own declared cwd"
+          end
+        end
+
+        def render_gate(g)
+          terminal.say ""
+          terminal.say "── #{g[:ac].empty? ? "(gate)" : g[:ac]}: #{g[:cmd]}  (exit #{g[:exit_code].inspect})  [#{g[:rehearsal].to_s.upcase}]"
+          terminal.say "   dir: #{terminal.path(g[:dir])}"
+          terminal.say "   reason: #{g[:reason]}" unless g[:reason].to_s.empty?
+          if g[:rehearsal] == :broken
+            terminal.say "   BROKEN is advisory, not certain — a correct RED can look broken (e.g. a file the lane " \
+              "hasn't written yet). Confirm before treating it as a defect."
+          end
+          terminal.say g[:stdout].rstrip unless g[:stdout].strip.empty?
+          terminal.say g[:stderr].rstrip unless g[:stderr].strip.empty?
+        end
+
+        # I12/AC3-AC4: reports scope asymmetry only — never affects RED/GREEN/
+        # BROKEN, rehearse's exit code, or the stamp. A file outside every
+        # declared lane's touch set is flagged loudest: it's the one no lane
+        # may legally fix. not_analyzable is rendered too, and counted, so a
+        # reader can tell "nothing matched" from "nothing was examined".
+        def render_scope_asymmetry(report)
+          return if report.nil? || (report[:findings].empty? && report[:not_analyzable].empty?)
+
+          terminal.say ""
+          terminal.say "Scope-asymmetry check (grep-family gates only):"
+          report[:findings].each do |f|
+            terminal.say "── #{f[:id]} (#{f[:repo]}): pattern #{f[:pattern].inspect} searched #{f[:paths].join(', ')}"
+            if f[:outside_lanes].any?
+              terminal.say "   OUTSIDE ANY LANE'S TOUCH SET — no lane may legally fix these:"
+              f[:outside_lanes].each { |file| terminal.say "     #{file}" }
+            end
+            terminal.say "   also matches (within a declared lane's touch set): #{f[:within_lanes].join(', ')}" if f[:within_lanes].any?
+            terminal.say "   0 files elsewhere match" if f[:outside_lanes].empty? && f[:within_lanes].empty?
+          end
+
+          return if report[:not_analyzable].empty?
+          terminal.say ""
+          terminal.say "Not analyzed (#{report[:not_analyzable].size} grep invocation(s)) — counted, not silently skipped:"
+          report[:not_analyzable].each { |na| terminal.say "   #{na[:id]}: #{na[:reason]}" }
+        end
+
+        def render_record(result)
+          return "> Rehearsed #{result[:iteration]} — no gates drafted; nothing to record." if result[:empty]
+
+          by  = result[:gates].group_by { |g| g[:rehearsal] }
+          ids = ->(sym) { (by[sym] || []).map { |g| g[:id] }.join(", ") }
+          ran_against = result[:repo] ? "against `#{result[:repo]}`" : "each in its own declared `cwd`"
+          [
+            "> **Dry-run at rehearsal time, recorded for transparency.** All #{result[:gates].size} gate command(s) " \
+              "were executed as written #{ran_against} under `/bin/sh` — the shell `architect gate` uses.",
+            ">",
+            "> - **RED (#{(by[:red] || []).size} — discriminate):** #{ids.call(:red).empty? ? "(none)" : ids.call(:red)}",
+            "> - **GREEN (#{(by[:green] || []).size} — regression guard or non-discriminating):** #{ids.call(:green).empty? ? "(none)" : ids.call(:green)}",
+            "> - **BROKEN (#{(by[:broken] || []).size} — advisory, confirm each):** #{ids.call(:broken).empty? ? "(none)" : ids.call(:broken)}"
+          ].join("\n")
+        end
+      end
+
       class Freeze < BaseCommand
         desc "Freeze the iteration's frozen region (Grounds/Specification/Acceptance Criteria) and record the freeze SHA"
-        phase 12, "Spec"
+        phase 13, "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)"
+        # Named --skip-rehearse, not --no-rehearse: Ruby's OptionParser (dry-cli's
+        # underlying parser, verified against the live dry-cli 1.4.1 in this repo)
+        # treats ANY switch literally named --no-<word> as a boolean negation and
+        # silently discards its value, regardless of declared type — so a REASON
+        # cannot bind to a flag spelled --no-rehearse. --skip-rehearse is the
+        # working escape valve; --no-rehearse is the name this design uses for it.
+        option   :skip_rehearse, default: nil, desc: "Escape valve (design name: --no-rehearse): skip the fresh-rehearsal requirement, recording REASON in space.yaml (bare freeze refuses without a matching `architect rehearse` stamp)"
         commit_message_options
 
-        def call(iteration:, space: nil, message: nil, message_from: nil, force: false, **opts)
+        def call(iteration:, space: nil, message: nil, message_from: nil, force: false, skip_rehearse: nil, **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, force: force,
+              sha = project.freeze!(iteration, warnings: warnings, force: force, skip_rehearse_reason: skip_rehearse,
                 message: read_commit_message(message: message, message_from: message_from))
               terminal.say "Frozen #{iteration} at #{sha}"
+              terminal.say "Rehearsal requirement skipped — #{skip_rehearse}" if skip_rehearse
               warnings.each { |w| terminal.say "Warning: #{w}" }
               ac = project.acceptance_criteria(iteration)
               unless ac.to_s.strip.empty?
@@ -316,6 +440,8 @@ module Space::Architect
         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, pi)"
+        option   :allowed_tools,        default: nil, desc: "Comma-separated tool list — replaces the claude-code --allowedTools grant for this dispatch (default: Read,Edit,Write,Grep,Glob,Bash,WebSearch,WebFetch). The lane's frozen allowed_tools: does the same with no flag; this flag wins over that key. Meaningless for opencode/pi"
+        option   :append_allowed_tools, default: nil, desc: "Comma-separated tool list — appends to the claude-code --allowedTools grant for this dispatch (to the flag/lane replace value, or the default). The lane's frozen append_allowed_tools: does the same with no flag; this flag wins over that key. Meaningless for opencode/pi"
         option   :effort,    default: nil,    desc: "Thinking/reasoning effort level — alias for --thinking/--reasoning (off, minimal, low, medium, high, xhigh, max); translated + clamped to the lane's harness"
         option   :thinking,  default: nil,    desc: "Thinking/reasoning effort level — alias for --effort/--reasoning (off, minimal, low, medium, high, xhigh, max); translated + clamped to the lane's harness"
         option   :reasoning, default: nil,    desc: "Thinking/reasoning effort level — alias for --effort/--thinking (off, minimal, low, medium, high, xhigh, max); translated + clamped to the lane's harness"
@@ -337,6 +463,7 @@ module Space::Architect
 
         def call(iteration:, lane:, space: nil, prompt: nil, model: nil,
                  max_turns: "200", harness: nil, effort: nil, thinking: nil, reasoning: nil,
+                 allowed_tools: nil, append_allowed_tools: nil,
                  force_effort: nil, force_thinking: nil, force_reasoning: nil, quiet: false, detach: false,
                  timeout: "14400", push_url: nil, push_token: nil, push_host: nil,
                  as_job: false, host: nil, token: nil, backend_url: nil, job_model: nil, api_key_ref: nil, **opts)
@@ -363,6 +490,8 @@ module Space::Architect
                 kwargs[:model]       = model           if model
                 kwargs[:harness]     = harness         if harness
                 kwargs[:effort]      = forced_level || level if forced_level || level
+                kwargs[:allowed_tools]        = allowed_tools        if allowed_tools
+                kwargs[:append_allowed_tools] = append_allowed_tools if append_allowed_tools
                 kwargs[:force]       = true            if forced_level
                 kwargs[:quiet]       = true             if quiet
                 kwargs[:job_model]   = job_model       if job_model
@@ -378,6 +507,8 @@ module Space::Architect
                 kwargs[:model]      = model           if model
                 kwargs[:harness]    = harness         if harness
                 kwargs[:effort]     = forced_level || level if forced_level || level
+                kwargs[:allowed_tools]        = allowed_tools        if allowed_tools
+                kwargs[:append_allowed_tools] = append_allowed_tools if append_allowed_tools
                 kwargs[:force]      = true            if forced_level
                 kwargs[:quiet]      = true             if quiet
                 kwargs[:timeout]    = timeout.to_i    unless detach
@@ -402,6 +533,9 @@ module Space::Architect
                   terminal.say "Report:  #{terminal.path(res[:report])}"
                   terminal.say "Ingest URL:  #{res[:push_url]}" if res[:push_url]
                   terminal.say "Builder exited with status #{res[:exit_code]}"
+                  unless res[:report].exist? && !res[:report].read.strip.empty?
+                    terminal.say "WARNING: no report at #{terminal.path(res[:report])} — the lane produced no deliverable."
+                  end
                   CLI.record_outcome(Outcome.new(exit_code: res[:exit_code]))
                 end
               end
@@ -429,8 +563,14 @@ module Space::Architect
                 terminal.say "No declared lanes to provision for '#{iteration}'"
               else
                 results.each do |r|
-                  state = r[:created] ? "created" : "already present"
-                  terminal.say "#{r[:lane]}: #{terminal.path(r[:worktree])} (#{state})"
+                  state = case r[:outcome]
+                  when :created   then "created"
+                  when :repointed then "re-pointed"
+                  else                 "already present"
+                  end
+                  line = "#{r[:lane]}: #{terminal.path(r[:worktree])} (#{state})"
+                  line += " — discarded #{r[:discarded]} uncommitted change(s), --force was given" if r[:discarded]
+                  terminal.say line
                 end
               end
               CLI.record_outcome(Outcome.new(exit_code: 0))
@@ -560,9 +700,11 @@ module Space::Architect
         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"
+        option   :accept_bounds, default: nil,  desc: "Escape valve: override the in-bounds check for these lanes when the frozen touch-set glob is itself the defect, recording REASON in space.yaml (never overrides the no-builder-commits check)"
+        option   :force, type: :boolean, default: false, desc: "Teardown-only: discard uncommitted work in a lane worktree instead of refusing (never overrides the mechanical merge checks)"
         commit_message_options
 
-        def call(iteration:, space: nil, lanes: nil, teardown: false, message: nil, message_from: nil, commit_mode: nil, into: nil, **opts)
+        def call(iteration:, space: nil, lanes: nil, teardown: false, message: nil, message_from: nil, commit_mode: nil, into: nil, accept_bounds: nil, force: false, **opts)
           setup_terminal(**opts.slice(:color, :colors))
           handle_errors do
             lane_names = lanes.to_s.split(",").map(&:strip).reject(&:empty?)
@@ -573,18 +715,21 @@ module Space::Architect
               project = ArchitectProject.new(space: sp)
               results = project.integrate!(iteration, lanes: lane_names, teardown: teardown,
                 message: read_commit_message(message: message, message_from: message_from),
-                commit_mode: commit_mode, into: into)
+                commit_mode: commit_mode, into: into, accept_bounds_reason: accept_bounds, force: force)
               if lane_names.empty?
                 if results.empty?
                   terminal.say "Nothing to tear down for #{iteration}"
                 else
                   results.each do |r|
-                    terminal.say "Tore down #{r[:lane]} (removed worktree, deleted #{r[:lane_branch]})"
+                    line = "Tore down #{r[:lane]} (removed worktree, deleted #{r[:lane_branch]})"
+                    line += " — discarded #{r[:discarded]} uncommitted change(s), --force was given" if r[:discarded]
+                    terminal.say line
                   end
                 end
               else
                 results.each do |r|
                   terminal.say "Merged #{r[:lane]} → #{r[:integration_branch]} (#{r[:merge_sha][0, 8]})"
+                  terminal.say "In-bounds check overridden for #{r[:lane]}: #{r[:bounds_override_reason]}" if r[:bounds_override_reason]
                 end
                 terminal.say "Gates NOT run — run gates: `architect gate #{iteration}`"
               end
@@ -611,6 +756,7 @@ module Space::Architect
                 marker = r[:status] == :pass ? "PASS" : "FAIL"
                 terminal.say ""
                 terminal.say "── #{r[:ac].empty? ? "(gate)" : r[:ac]}: #{r[:cmd]}  (exit #{r[:exit_code]})  [#{marker}]"
+                terminal.say "   dir: #{terminal.path(r[:dir])}"
                 terminal.say "   reason: #{r[:reason]}" if r[:status] == :fail && !r[:reason].to_s.empty?
                 terminal.say r[:stdout].rstrip unless r[:stdout].strip.empty?
                 terminal.say r[:stderr].rstrip unless r[:stderr].strip.empty?
@@ -627,15 +773,20 @@ module Space::Architect
       class BugReport < BaseCommand
         desc "Generate a prefilled GitHub issue template for filing bugs against space-architect"
         phase 54, "Project"
+        option :title, default: nil, desc: "Issue title, written into --title and the body's leading H1 (omit and gh will prompt for one interactively — the body file does not set it)"
 
-        def call(**opts)
+        def call(title: nil, **opts)
           setup_terminal(**opts.slice(:color, :colors))
           handle_errors do
             space = store.find.value_or(nil)
             result = Space::Architect::BugReport.generate(
               space: space,
-              env: project_config.env
+              env: project_config.env,
+              title: title
             )
+            unless title
+              terminal.say "No --title given — the body file does not set the issue title; re-run as architect bug-report --title \"...\" to set it in the command (or gh will prompt you for one)."
+            end
             terminal.say "Fill the placeholders in #{terminal.path(result[:body_path].to_s)}, then run:"
             terminal.say result[:command]
             terminal.say ""
@@ -677,6 +828,7 @@ module Space::Architect
           argument :repo,      required: true, desc: "Repo name (under repos/)"
           argument :iteration, required: true, desc: "Iteration name"
           argument :lane,      required: true, desc: "Lane name"
+          argument :space,     required: false, desc: "Space identifier (default: $PWD)"
           option   :base,      default: nil,          desc: "Base ref (default: HEAD of repo)"
           option   :harness,   default: nil,          desc: "Harness (claude-code, opencode, pi; default: space.yaml project.harness, else claude-code)"
           option   :model,     default: nil,           desc: "Model; a trailing :<level> suffix (e.g. foo:high) is parsed into --effort (default: space.yaml project.model, else the per-harness sensible default)"
@@ -687,12 +839,12 @@ module Space::Architect
           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: nil, model: nil,
+          def call(repo:, iteration:, lane:, space: nil, 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|
+              render(store.find(space)) do |sp|
                 project = ArchitectProject.new(space: sp)
                 touch_set = touch ? touch.split(",").map(&:strip).reject(&:empty?) : nil
                 err = quiet ? File.open(File::NULL, "w") : $stderr
@@ -700,6 +852,7 @@ module Space::Architect
                                              effort: level, touch: touch_set, force: force, err: err)
                 terminal.say "Worktree: #{terminal.path(result[:worktree])}"
                 terminal.say "Base SHA: #{result[:base_sha]}"
+                terminal.say "Discarded #{result[:discarded]} uncommitted change(s), --force was given" if result[:discarded]
                 CLI.record_outcome(Outcome.new(exit_code: 0))
               end
             end
@@ -710,14 +863,23 @@ module Space::Architect
           desc "Remove a lane worktree"
           argument :iteration, required: true, desc: "Iteration name"
           argument :lane,      required: true, desc: "Lane name"
+          argument :space,     required: false, desc: "Space identifier (default: $PWD)"
+          option   :force,     type: :boolean, default: false, desc: "Discard uncommitted work in the worktree (untracked files included) instead of refusing"
 
-          def call(iteration:, lane:, **opts)
+          def call(iteration:, lane:, space: nil, force: false, **opts)
             setup_terminal(**opts.slice(:color, :colors))
             handle_errors do
-              render(store.find) do |sp|
+              render(store.find(space)) do |sp|
                 project = ArchitectProject.new(space: sp)
-                project.worktree_remove(iteration, lane)
+                result = project.worktree_remove(iteration, lane, force: force)
                 terminal.say "Removed worktree for #{iteration}/#{lane}"
+                if result[:discarded]
+                  terminal.say "Discarded #{result[:discarded]} uncommitted change(s), --force was given"
+                end
+                if result[:branch_survives]
+                  terminal.say "Lane branch '#{result[:branch]}' survives — this is not a reset; " \
+                    "re-provisioning re-points or refuses it, it does not start it over."
+                end
                 CLI.record_outcome(Outcome.new(exit_code: 0))
               end
             end
@@ -726,11 +888,12 @@ module Space::Architect
 
         class List < BaseCommand
           desc "List active architect worktrees"
+          argument :space, required: false, desc: "Space identifier (default: $PWD)"
 
-          def call(**opts)
+          def call(space: nil, **opts)
             setup_terminal(**opts.slice(:color, :colors))
             handle_errors do
-              render(store.find) do |sp|
+              render(store.find(space)) do |sp|
                 project = ArchitectProject.new(space: sp)
                 worktrees = project.worktree_list
                 if worktrees.empty?
@@ -1090,6 +1253,7 @@ Space::Architect::CLI::Registry.register "ground", Space::Architect::CLI::Archit
 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 "rehearse", Space::Architect::CLI::Architect::Rehearse
 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/cli/research.rb

@@ -6,8 +6,8 @@ module Space::Architect
       module Research
         class Dispatch < BaseCommand
           desc "Dispatch detached read-only research lanes (one per prompt file)"
-          argument :prompts, required: true,
-                             desc: "Prompt file(s) to dispatch (space-separated paths)"
+          argument :prompts, type: :array, required: true,
+            desc: "Prompt file(s) to dispatch (space-separated paths)"
           option :model,     default: nil, desc: "Researcher model override (default: the reference default claude-sonnet-4-6)"
           option :max_turns, default: "40", desc: "Max turns per researcher"
 
@@ -15,11 +15,10 @@ module Space::Architect
             setup_terminal(**opts.slice(:color, :colors))
             handle_errors do
               render(store.find(opts[:space])) do |sp|
-                paths = Array(prompts)
                 supervisor = Space::Architect::Research::Supervisor.new(space: sp)
                 kwargs = { max_turns: max_turns.to_i }
                 kwargs[:model] = model if model
-                runs = supervisor.dispatch(paths, **kwargs)
+                runs = supervisor.dispatch(prompts, **kwargs)
                 runs.each do |run|
                   terminal.say "dispatched #{run.id} (pid #{run.pid}) → #{terminal.path(run.run_log_path)}"
                 end

data/lib/space_architect/harness.rb

@@ -62,13 +62,16 @@ module Space::Architect
     # (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, force: false, err: $stderr)
+    def self.for(name, model:, max_turns:, bin: nil, config_dir: nil, effort: nil, allowed_tools: 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"
-        ClaudeCodeHarness.new(model: model, max_turns: max_turns, bin: bin, effort: translated)
+        kwargs = { model: model, max_turns: max_turns, bin: bin, effort: translated }
+        kwargs[:allowed_tools] = allowed_tools if allowed_tools
+        ClaudeCodeHarness.new(**kwargs)
       when "opencode"
         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: translated)
@@ -93,6 +96,15 @@ module Space::Architect
       ACCEPTED_LEVELS = %w[low medium high xhigh max].freeze
       CLAMP_MAP = { "minimal" => "low" }.freeze
 
+      # #89: compose the --allowedTools value from an optional replace + append pair —
+      # resolved once here regardless of which surface (--allowed-tools/--append-allowed-tools
+      # flag, or the lane's frozen allowed_tools:/append_allowed_tools: declaration) supplied
+      # them, since replace/append combine identically either way.
+      def self.resolve_tools(replace: nil, append: nil)
+        base = replace || ALLOWED_TOOLS
+        append ? "#{base},#{append}" : base
+      end
+
       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
@@ -115,10 +127,19 @@ module Space::Architect
 
       TIMEOUT_EXIT_CODE = 124
 
-      # How long the liveness fiber waits before reading the run log's stream-json init
-      # event. Injectable via the run(liveness_delay:) kwarg so tests need not sleep seconds.
+      # The liveness fiber's total wait budget before it gives up on the run log's
+      # stream-json init event. Injectable via the run(liveness_delay:) kwarg so tests
+      # need not sleep seconds.
       LIVENESS_DELAY_SECONDS = 5.0
 
+      # The liveness fiber's actual deadline is liveness_delay * LIVENESS_BUDGET_FACTOR —
+      # a healthy child whose first write lands just after one delay window is still
+      # alive, not dead, so the budget spans several delay-lengths, not one.
+      LIVENESS_BUDGET_FACTOR = 3
+
+      # How often the liveness fiber re-checks the run log for growth while waiting.
+      LIVENESS_POLL_INTERVAL = 0.05
+
       def run(prompt_path:, run_log_path:, chdir:, push_url: nil, push_token: nil, push_client: nil, timeout: nil,
               liveness_delay: LIVENESS_DELAY_SECONDS, err: $stderr)
         prompt_path  = Pathname.new(prompt_path)
@@ -148,15 +169,24 @@ module Space::Architect
                 end
               end
 
-              # Liveness self-check: after a bounded delay, read the run log's stream-json
-              # init event and print ONE line naming the streamed model + confirming growth.
-              # transient: true so it never keeps the reactor alive; best-effort so it never
-              # raises into the run path. run_detached gets no such fiber.
+              # Liveness self-check: read the run log's stream-json init event and print ONE
+              # line naming the streamed model + true elapsed time. A single point-sample right
+              # at liveness_delay would report a healthy child dead if its first write landed a
+              # moment later, so this polls (like Research::Mux#wait_for_file) to a deadline of
+              # several delay-lengths, emitting as soon as the log holds a parseable init event —
+              # a bounded wait, not an unbounded one, and not satisfied by mere non-emptiness (the
+              # child's stderr is teed into the same run log, so one early stderr byte must not
+              # count). transient: true so it never keeps the reactor alive; best-effort so it
+              # never raises into the run path. run_detached gets no such fiber.
               liveness_task = nil
               if liveness_delay && liveness_delay > 0
                 liveness_task = Async(transient: true) do
-                  sleep liveness_delay
-                  emit_liveness(run_log_path, liveness_delay, err)
+                  start    = Time.now
+                  deadline = start + (liveness_delay * LIVENESS_BUDGET_FACTOR)
+                  until init_event_ready?(run_log_path) || Time.now >= deadline
+                    sleep LIVENESS_POLL_INTERVAL
+                  end
+                  emit_liveness(run_log_path, Time.now - start, err)
                 end
               end
 
@@ -207,18 +237,60 @@ module Space::Architect
 
       private
 
+      # The liveness fiber's wait predicate: ready once the run log holds a parseable
+      # stream-json init event — not merely once it holds any bytes, since the child's
+      # stderr is teed into the same run log and one early stderr byte must not satisfy it.
+      #
+      # Scans only the bytes appended since the previous poll (remembering the offset
+      # in @liveness_offset) instead of re-parsing the whole log from the top on every
+      # 50ms tick — the child that never emits an init event would otherwise cost
+      # O(polls x log size) inside a fiber sharing the reactor with the dispatch itself.
+      def init_event_ready?(run_log_path)
+        return true if @liveness_model
+
+        @liveness_offset ||= 0
+        File.open(run_log_path, "r") do |f|
+          f.seek(@liveness_offset)
+          f.each_line do |line|
+            break unless line.end_with?("\n")
+            @liveness_offset = f.pos
+            ev = begin
+              JSON.parse(line)
+            rescue JSON::ParserError
+              next
+            end
+            next unless ev.is_a?(Hash) && ev["type"] == "system" && ev["subtype"] == "init"
+            @liveness_model = ev["model"]
+            break
+          end
+        end
+        !@liveness_model.nil?
+      rescue StandardError
+        false
+      end
+
       # Read the run log's stream-json init event and print exactly one bounded liveness
-      # line to err. Best-effort: swallows any read/parse error so it never raises into run.
-      def emit_liveness(run_log_path, delay, err)
+      # line to err, naming the true elapsed wall-clock time since dispatch. Best-effort:
+      # swallows any read/parse error so it never raises into run.
+      #
+      # Reuses init_event_ready?'s own incremental scan rather than re-parsing the
+      # whole log from the top: when the poll loop already found the init event,
+      # @liveness_model is set and this is a no-op re-check; when it ended on the
+      # deadline without one, this performs exactly one more forward scan from
+      # @liveness_offset, so bytes appended between the last poll and this call are
+      # still observed — a scan forward from the cached offset, never a skipped one.
+      def emit_liveness(run_log_path, elapsed, err)
         bytes = run_log_path.exist? ? run_log_path.size : 0
+        elapsed = elapsed.round(1)
         if bytes.zero?
-          err.puts "liveness: WARN no growth — run log still empty #{delay}s after dispatch"
+          err.puts "liveness: WARN no growth — run log still empty #{elapsed}s after dispatch"
           return
         end
 
-        streamed = streamed_init_model(run_log_path)
+        init_event_ready?(run_log_path)
+        streamed = @liveness_model
         if streamed.nil?
-          err.puts "liveness: WARN model unverified — no stream-json init event after #{delay}s (run log #{bytes} bytes)"
+          err.puts "liveness: WARN model unverified — no stream-json init event after #{elapsed}s (run log #{bytes} bytes)"
         elsif streamed == @model
           err.puts "liveness: OK streaming model=#{streamed} (run log growing, #{bytes} bytes)"
         else
@@ -228,21 +300,6 @@ module Space::Architect
         # Best-effort: an internal read/parse failure must never break the run.
       end
 
-      # The model named by the stream-json init event ({"type":"system","subtype":"init",...}),
-      # or nil if no such event has been logged yet.
-      def streamed_init_model(run_log_path)
-        run_log_path.each_line do |line|
-          ev = begin
-            JSON.parse(line)
-          rescue JSON::ParserError
-            next
-          end
-          next unless ev.is_a?(Hash) && ev["type"] == "system" && ev["subtype"] == "init"
-          return ev["model"]
-        end
-        nil
-      end
-
       def argv
         [@bin, "-p", "--model", @model, "--output-format", "stream-json", "--verbose"] + builder_args
       end

data/lib/space_architect/session_sync/runner.rb

@@ -53,8 +53,10 @@ module Space::Architect
       end
 
       def files
-        pi = Dir.glob(File.join(@pi_root, "**", "*.jsonl")).map { |p| [p, SessionId.for_pi(p)] }
-        claude = Dir.glob(File.join(@claude_root, "**", "*.jsonl")).map { |p| [p, SessionId.for_claude(p)] }
+        pi = Space::Core::Paths.content_tree(@pi_root).select { |p| p.end_with?(".jsonl") }
+          .map { |p| [p, SessionId.for_pi(p)] }
+        claude = Space::Core::Paths.content_tree(@claude_root).select { |p| p.end_with?(".jsonl") }
+          .map { |p| [p, SessionId.for_claude(p)] }
         pi + claude
       end
     end