space-architect 6.0.0 → 7.1.0

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"]
@@ -254,30 +262,81 @@ module Space::Architect
 
         private
 
+        # I01: inline output is bounded — one identity line per gate, ≤ 20
+        # lines of tail output — because the full report always lands in the
+        # transcript #render_gate points at. The summary block is emitted last
+        # (after the disclaimer) so a `tail` of stdout captures it whole.
         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 "Rehearsing #{result[:iteration]} against #{terminal.path(result[:base_dir])} (repo: #{result[:repo]})"
-            result[:gates].each { |g| render_gate(g) }
-            render_scope_asymmetry(result[:scope_asymmetry])
+            terminal.say ""
+            terminal.say discrimination_note
+            return
           end
+
+          terminal.say rehearsal_header(result)
+          result[:gates].each { |g| render_gate(g, result[:transcript]) }
+          render_scope_asymmetry(result[:scope_asymmetry])
           terminal.say ""
-          terminal.say "Discrimination report only — this runs and reports; it never judges whether these gates are good, bad, or ready."
+          terminal.say discrimination_note
+          render_summary(result)
+        end
+
+        def discrimination_note
+          "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)
+        # I01/AC "bounded terminal report": identity (AC label, gate id, verdict,
+        # exit code) always lands on one stdout line, however many lines `cmd`
+        # spans — the command itself is shown as at most its first line,
+        # truncated; the full command lives in the transcript.
+        CMD_LINE_MAX    = 100
+        OUTPUT_LINE_CAP = 20
+
+        def render_gate(g, transcript_path)
           terminal.say ""
-          terminal.say "── #{g[:ac].empty? ? "(gate)" : g[:ac]}: #{g[:cmd]}  (exit #{g[:exit_code].inspect})  [#{g[:rehearsal].to_s.upcase}]"
+          terminal.say "── #{g[:ac].empty? ? "(gate)" : g[:ac]} #{g[:id]}: #{truncated_cmd(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[:shared_with]&.any?
+            terminal.say "   shared execution with: #{g[:shared_with].join(', ')} (identical cmd+dir, captured once)"
+          end
           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?
+          render_gate_output(g, transcript_path)
+        end
+
+        def truncated_cmd(cmd)
+          first, *rest = cmd.to_s.each_line.map(&:chomp)
+          clipped = first.length > CMD_LINE_MAX ? "#{first[0, CMD_LINE_MAX]}…" : first
+          rest.any? || clipped != first ? "#{clipped} …" : clipped
+        end
+
+        def render_gate_output(g, transcript_path)
+          combined = [g[:stdout], g[:stderr]].map { |s| s.to_s.rstrip }.reject(&:empty?).join("\n")
+          return if combined.empty?
+
+          lines = combined.lines(chomp: true)
+          if lines.size > OUTPUT_LINE_CAP
+            terminal.say lines.last(OUTPUT_LINE_CAP).join("\n")
+            terminal.say "   … #{lines.size - OUTPUT_LINE_CAP} more line(s) elided — full output in #{terminal.path(transcript_path)}"
+          else
+            terminal.say lines.join("\n")
+          end
         end
 
         # I12/AC3-AC4: reports scope asymmetry only — never affects RED/GREEN/
@@ -291,7 +350,7 @@ module Space::Architect
           terminal.say ""
           terminal.say "Scope-asymmetry check (grep-family gates only):"
           report[:findings].each do |f|
-            terminal.say "── #{f[:id]}: pattern #{f[:pattern].inspect} searched #{f[:paths].join(', ')}"
+            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}" }
@@ -306,14 +365,31 @@ module Space::Architect
           report[:not_analyzable].each { |na| terminal.say "   #{na[:id]}: #{na[:reason]}" }
         end
 
+        # I01: always-on, positioned last so a `tail` of stdout captures it
+        # whole — one line per gate (AC label, gate id, verdict; reason
+        # appended for RED/BROKEN), a tally by verdict, and the transcript path.
+        def render_summary(result)
+          terminal.say ""
+          terminal.say "Summary:"
+          result[:gates].each do |g|
+            line = "  #{g[:ac].empty? ? "(gate)" : g[:ac]} #{g[:id]} [#{g[:rehearsal].to_s.upcase}]"
+            line += " — #{g[:reason]}" if %i[red broken].include?(g[:rehearsal]) && !g[:reason].to_s.empty?
+            terminal.say line
+          end
+          tally = result[:gates].group_by { |g| g[:rehearsal] }.transform_values(&:size)
+          terminal.say "  #{%i[green red broken].filter_map { |v| "#{v.to_s.upcase}: #{tally[v]}" if tally[v] }.join(', ')}"
+          terminal.say "  transcript: #{terminal.path(result[:transcript])}"
+        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 against `#{result[:repo]}` under `/bin/sh` — the shell `architect gate` uses.",
+              "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)}",
@@ -420,6 +496,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"
@@ -441,6 +519,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)
@@ -467,6 +546,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
@@ -482,6 +563,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
@@ -536,8 +619,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))
@@ -668,9 +757,10 @@ module Space::Architect
         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, accept_bounds: 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?)
@@ -681,13 +771,15 @@ 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, accept_bounds_reason: accept_bounds)
+                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
@@ -792,6 +884,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)"
@@ -802,12 +895,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
@@ -815,6 +908,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
@@ -825,14 +919,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
@@ -841,11 +944,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?

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

data/lib/space_core/version.rb

@@ -2,6 +2,6 @@
 
 module Space
   module Core
-    VERSION = "6.0.0"
+    VERSION = "7.1.0"
   end
 end

data/skill/architect/SKILL.md

@@ -277,7 +277,9 @@ contract, self-contained:
   its **target repo + file-touch set, checked for overlap**: name the repo
   (`repos/<repo>`) and every file each lane may touch. The machine-readable
   declaration lives in a fenced ` ```lanes ` block in the Specification — one
-  entry per lane (`name`, `repo`, `touch` globs) — the single frozen source of
+  entry per lane (`name`, `repo`, `touch` globs; optionally `allowed_tools`/
+  `append_allowed_tools` to replace/extend the lane's builder tool grant — see
+  `dispatch.md`) — the single frozen source of
   truth `architect freeze` records into `space.yaml` and `architect provision`
   materializes. The same boundary is stated twice more — the lane-prompt's
   may-touch list, and the scope gate that checks the lane's diff at judge
@@ -298,12 +300,15 @@ contract, self-contained:
   overlap run as one. Each lane gets its own objective, output format, and
   boundaries. Most
   iterations are one lane — fan out only when the work is genuinely parallel (a
-  cross-repo project often is). Two first-class patterns — runnable recipes in `dispatch.md`: **parallel +
+  cross-repo project often is). Three first-class patterns — runnable recipes in `dispatch.md`: **parallel +
   fast-follow** (disjoint lanes integrate first; a fast-follow lane off
-  `project/<slug>` carries the seam — see `### Parallel + fast-follow`) and
+  `project/<slug>` carries the seam — see `### Parallel + fast-follow`),
   **serial deferred judgment** (iterations run to gates-green with `architect
   verdict` withheld; one later batch session judges each against its own frozen
-  AC — see `### Serial deferred judgment`).
+  AC — see `### Serial deferred judgment`), and **long-running sweep** (a lane
+  launches its own long detached process, ends its session at a sanctioned
+  pending status, and a later session in the same worktree audits it once it
+  exits — see `### Long-running sweep` in `dispatch.md`).
 - **Effort call** — thinking budget set per dispatch with `architect dispatch
   --effort <level>`, translated and clamped to the lane's harness (the
   escalation keywords `think hard` … `ultrathink` still work in-prompt);
@@ -376,9 +381,13 @@ architect-read.
   that measures nothing; **BROKEN**, a 127 / syntax error / timeout —
   advisory, because a correct RED can look broken (`grep -q x` on a file the
   lane will write exits 2): the tool names the suspicion, you confirm;
-  **EMPTY**, no gates or an untouched placeholder. `--record` emits a
-  paste-able provenance block for the AC preamble. It reports; which GREENs
-  are guards and which are defects stays your call.
+  **EMPTY**, no gates or an untouched placeholder. Every non-EMPTY run writes
+  a full transcript (every gate's command, dir, exit code, verdict, reason,
+  complete stdout+stderr) under `build/rehearse/`, prints its path, and ends
+  with a bounded summary — one line per gate plus a tally — so a rerun is
+  never needed just to re-see output the terminal already trimmed. `--record`
+  emits a paste-able provenance block for the AC preamble. It reports; which
+  GREENs are guards and which are defects stays your call.
 
 Then run `architect freeze <name>`. Freeze requires a fresh rehearsal stamp —
 `rehearse` records one in `space.yaml`, keyed to the gates block's content, so
@@ -402,7 +411,8 @@ Per the mechanics in `dispatch.md`. The lane lifecycle is **declare → rehearse
 there is no dispatch-in-the-checkout path:
 
 - **Declare** — at spec time, each lane is one entry in the Specification's
-  fenced ` ```lanes ` block (§4): `name`, `repo`, `touch` globs.
+  fenced ` ```lanes ` block (§4): `name`, `repo`, `touch` globs, and optionally
+  `allowed_tools`/`append_allowed_tools`.
 - **Rehearse** — `architect rehearse <iteration>` dry-runs the drafted gates
   from the working tree (§4's pre-freeze check), resolving its run dir from the
   drafted ` ```lanes ` block, and stamps `space.yaml`; `freeze` refuses without
@@ -488,7 +498,10 @@ only the per-lane `lane/<iteration>-<lane>` branches and worktrees, never the
 project branch. Update the iteration index in `architecture/ARCHITECT.md`
 (recording the `project/<slug>` branch), remove the provisioned worktrees
 (`architect integrate … --teardown`, or `architect worktree remove <iteration>
-<lane>`), and commit the space.
+<lane>`), and commit the space. Both refuse per lane when its worktree still
+holds uncommitted work — untracked files included; `--force` overrides and
+discards it. The `--lanes` integration path itself is unaffected, since
+`integrate` commits each lane's work before teardown.
 
 **Run the frozen gates cold** — `architect gate <iteration>` runs the frozen
 gate commands against the integration tree and streams raw output (a runner, not

data/skill/architect/dispatch.md

@@ -145,7 +145,12 @@ spec defect: kill the conflicting lane and re-spec; don't hand-resolve builder
 conflicts. It runs **no gates and makes no verdict** — `architect gate` streams
 the raw gate output for you to judge. `--teardown` deletes only the per-lane
 `lane/<iteration>-<lane>` branches and worktrees; it never deletes the
-`project/<slug>` branch.
+`project/<slug>` branch. Every destructive lane operation — `worktree remove`,
+`integrate --teardown`, and the re-point path of `provision --base` — refuses
+per lane when that lane's worktree still holds uncommitted work, untracked
+files included, because that's what a dispatched lane always holds; `--force`
+overrides and discards it. The `--lanes <passing-set>` integration path itself
+is unaffected — `integrate` commits each lane's work before tearing it down.
 
 Under the hood / manual fallback (one lane shown):
 
@@ -261,6 +266,66 @@ rests on a foundation that a later KILL at N would revert. Accept this coupling
 only consciously, and always judge oldest-first so a KILL stops you before you
 compound it.
 
+### Long-running sweep (detached, two-phase)
+
+Use when a lane's own work *is* a long-running detached process — a 30–70
+minute sweep, migration, or batch run the lane must launch, let run
+unattended, and then audit once it exits. A metered builder session paying
+tokens to sit in a poll loop is the wrong instrument for that wait: split the
+lane across two builder sessions instead, one before the process runs and one
+after.
+
+**Recipe:**
+
+1. **Phase A — launch, prove liveness, stop deliberately.** The lane-prompt's
+   PHASE 2 tells the builder to launch the process detached (backgrounded and
+   redirected to a log file, survives the builder's own process exit), capture
+   its pid, prove it's alive with one command result (e.g. `ps -p <pid>` plus a
+   growing log tail — not an assertion), pre-structure the report with the
+   sections phase B will fill in, and end the session there — not mid-poll —
+   at:
+   ```
+   STATUS: SWEEP_RUNNING (pid <pid>, run dir <path>)
+   ```
+   `SWEEP_RUNNING` is the fixed token spec authors and architects grep for;
+   the pid and run dir ride in the same line because nothing else in the loop
+   captures them.
+
+2. **The wait belongs to the architect's harness, not the builder session.**
+   Between phase A and B, a process-exit monitor on the architect's side —
+   notification-driven, not a poll loop — watches for the pid to exit. A
+   builder session spends tokens to sit idle in a wait; the harness doesn't.
+   Do not dispatch a phase-B session, or resume one, until the process has
+   actually exited.
+
+3. **Phase B — resume and audit.** Once the process has exited, resume the
+   same lane worktree with `--continue` — the one sanctioned use of
+   `--continue` beyond same-lane follow-ups (see `## Operating guidance`
+   below) — and hand it the post-run audit as the new instruction:
+   ```bash
+   ( cd build/<id>-<lane>/wt && \
+     echo "The sweep at <run dir> (pid <pid>) has exited. Audit its output
+   against the spec's acceptance criteria, finish the report you
+   pre-structured in phase A, and end at STATUS: COMPLETE." \
+     | claude -p --continue --model <builder-model> \
+       --permission-mode acceptEdits \
+       --allowedTools 'Read,Edit,Write,Grep,Glob,Bash,WebSearch,WebFetch' \
+       --disallowedTools 'Bash(git commit:*),Bash(git push:*),Bash(git reset:*),Bash(git merge:*),Bash(git rebase:*),Bash(git checkout:*),Bash(git branch:*)' \
+       --output-format stream-json --verbose \
+       > build/<id>-<lane>/run-b.jsonl 2>&1 )
+   ```
+   Phase B runs the post-run audits the spec asked for, then finishes the
+   report at `STATUS: COMPLETE` (or `COMPLETE_WITH_CONCERNS`/`BLOCKED`, per the
+   template) exactly as any other lane would.
+
+**Invariant:** phase A never ends mid-poll or at a pending status of its own
+invention — it ends at `SWEEP_RUNNING` with the pid and run dir recorded, or
+it's indistinguishable from a lane that gave up. Spec authors: an in-lane
+"poll until it finishes" / "never end the session while it runs" instruction
+loses to the template's no-busy-wait clause below every time a builder holds
+both — write this two-phase shape into the lane spec instead of a poll
+instruction.
+
 ## Operating guidance
 
 - Background each lane as its own harness task and let the **per-lane
@@ -282,6 +347,19 @@ compound it.
   `ultrathink`) and the `MAX_THINKING_TOKENS` env var still raise depth from
   inside the block. Default unattended builder work to a high budget; downgrade
   a routine, tightly-specified lane (record which and why in the spec).
+- **Tool grant.** The default `--allowedTools` list is overridable per dispatch:
+  `--allowed-tools <list>` replaces it, `--append-allowed-tools <list>` appends
+  to it. The same is settable in the frozen lane declaration's ` ```lanes ` block
+  — `allowed_tools:` (replaces) / `append_allowed_tools:` (appends) — so a lane
+  that needs an MCP or other non-default tool is granted it reviewably, judged
+  like every other lane boundary, rather than buried in a shell invocation. The
+  CLI flag wins over the lane's yaml key when both are given, and dispatch
+  reports which source resolved. This exists because `claude -p` **denies** a
+  tool not on the allow list rather than prompting for it — a lane missing a
+  needed grant doesn't error, it silently can't use the tool and files a
+  confident, dataless report instead. `--disallowedTools`/`DISALLOWED_TOOLS`
+  (the builder-never-commits deny rules above) has no override route, by design
+  — hard rule 7 depends on it staying fixed.
 - **Builders never commit, and the architect verifies it.** Claude Code has no
   sandbox to make `.git` read-only, so this is enforced by the deny rules at
   dispatch *and* checked after the run: before integrating a lane, confirm
@@ -400,7 +478,11 @@ backgrounded work is SIGTERMed and its output lost while the run still exits
 potentially long command an explicit timeout; if a
 runtime will not start unattended (interactive prompt, server with no timeout),
 record the exact failure in your report and route around it — never busy-wait
-or retry in a loop. When done, write your report to the scratch file given to
+or retry in a loop. The one sanctioned exception is a deliberate wait on a
+detached process this lane itself launched: end that phase at
+`STATUS: SWEEP_RUNNING` (pid + run dir) per `### Long-running sweep` in
+dispatch.md, instead of polling for it to finish — this clause still forbids
+retry loops and sitting on an unattended runtime with no timeout. When done, write your report to the scratch file given to
 you, build/<id>-<lane>/report.md (an absolute path outside your worktree),
 with RAW results only — tables, numbers, command output — no interpretation, no
 "promising". Every status claim must be backed by a command result from this

metadata

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