space-architect 2.0.2 → 4.0.0

data/lib/space_architect/cli/architect.rb

@@ -4,9 +4,23 @@ require "json"
 
 module Space::Architect
   module CLI
+    # Optional loop-phase DSL on the shared command base, read by
+    # Space::Core::CLI::Help to group the help listing. A command may declare
+    # `phase <order>, "<Label>"`; groups, and members within a group, sort by
+    # <order>. Only architect commands declare one — space commands leave it nil
+    # and render as the single ungrouped default listing (unchanged).
+    class BaseCommand
+      def self.phase(order = nil, label = nil)
+        return @phase if order.nil?
+
+        @phase = [order, label]
+      end
+    end
+
     module Architect
       class Init < BaseCommand
         desc "Scaffold (or top up) the architect project: ARCHITECT.md, space.yaml project block, SessionStart hook"
+        phase 50, "Project"
         argument :space, required: false, desc: "Space identifier (default: $PWD)"
 
         def call(space: nil, **opts)
@@ -24,6 +38,7 @@ module Space::Architect
 
       class Ground < BaseCommand
         desc "Print grounding reads (ARCHITECT.md, BRIEF.md, in-flight iteration) to stdout"
+        phase 51, "Project"
         argument :space, required: false, desc: "Space identifier (default: $PWD)"
 
         def call(space: nil, **opts)
@@ -56,6 +71,7 @@ module Space::Architect
 
       class New < BaseCommand
         desc "Scaffold the next iteration file (architecture/I<NN>-<iteration>.md)"
+        phase 10, "Spec"
         argument :iteration, required: true,  desc: "Iteration name (kebab-case)"
         argument :space,     required: false, desc: "Space identifier (default: $PWD)"
 
@@ -74,6 +90,7 @@ module Space::Architect
 
       class Status < BaseCommand
         desc "Show architect project state (read-only)"
+        phase 52, "Project"
         argument :space, required: false, desc: "Space identifier (default: $PWD)"
 
         def call(space: nil, **opts)
@@ -126,6 +143,7 @@ module Space::Architect
 
       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)"
 
@@ -152,6 +170,7 @@ 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)"
 
@@ -199,6 +218,7 @@ module Space::Architect
 
       class Dispatch < BaseCommand
         desc "Dispatch a builder for a lane (streams to build/<id>-<lane>/run.jsonl)"
+        phase 21, "Build"
         argument :iteration, required: true,  desc: "Iteration name"
         argument :lane,      required: true,  desc: "Lane name"
         argument :space,     required: false, desc: "Space identifier (default: $PWD)"
@@ -251,8 +271,37 @@ module Space::Architect
         end
       end
 
+      class Provision < BaseCommand
+        desc "Materialize declared lanes (worktree + lane/<id>-<lane> branch) from the frozen lane plan"
+        phase 20, "Build"
+        argument :iteration, required: true,  desc: "Iteration name"
+        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)"
+
+        def call(iteration:, space: nil, base: nil, lane: nil, **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)
+              if results.empty?
+                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})"
+                end
+              end
+              CLI.record_outcome(Outcome.new(exit_code: 0))
+            end
+          end
+        end
+      end
+
       class Section < BaseCommand
         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 :space,     required: false, desc: "Space identifier (default: $PWD)"
@@ -292,6 +341,7 @@ module Space::Architect
 
       class Verdict < BaseCommand
         desc "Record the architect's verdict decision (continue or kill) and write ## Verdict prose"
+        phase 33, "Judge"
         argument :iteration, required: true,  desc: "Iteration name"
         argument :decision,  required: true,  desc: "Decision: continue or kill"
         argument :space,     required: false, desc: "Space identifier (default: $PWD)"
@@ -324,6 +374,7 @@ module Space::Architect
 
       class Evidence < BaseCommand
         desc "Transcribe a lane's scratch report VERBATIM into Builder Report and commit"
+        phase 31, "Judge"
         argument :iteration, required: true,  desc: "Iteration name"
         argument :space,     required: false, desc: "Space identifier (default: $PWD)"
         option   :lane,      default: nil,    desc: "Lane name (per-lane subsection; omit for a single-lane iteration)"
@@ -345,6 +396,7 @@ 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)"
@@ -367,42 +419,35 @@ 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: true,  desc: "Comma-separated passing lane names (you decide the set)"
+        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"
 
-        def call(iteration:, space: nil, lanes:, teardown: false, **opts)
+        def call(iteration:, space: nil, lanes: nil, teardown: false, **opts)
           setup_terminal(**opts.slice(:color, :colors))
           handle_errors do
-            render(store.find(space)) do |sp|
-              project = ArchitectProject.new(space: sp)
-              lane_names = lanes.to_s.split(",").map(&:strip).reject(&:empty?)
-              results = project.integrate!(iteration, lanes: lane_names, teardown: teardown)
-              results.each do |r|
-                terminal.say "Merged #{r[:lane]} → #{r[:integration_branch]} (#{r[:merge_sha][0, 8]})"
-              end
-              terminal.say "Gates NOT run — run `architect gate #{iteration}`; the verdict is the next session's."
-              CLI.record_outcome(Outcome.new(exit_code: 0))
-            end
-          end
-        end
-      end
+            lane_names = lanes.to_s.split(",").map(&:strip).reject(&:empty?)
+            raise Space::Core::Error, "integrate needs --lanes <set>, or --teardown for teardown-only" \
+              if lane_names.empty? && !teardown
 
-      class Land < BaseCommand
-        desc "Generate the end-of-project PR command (no push, no gh — prints gh pr create)"
-        argument :space, required: false, desc: "Space identifier (default: $PWD)"
-
-        def call(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.land
-              results.each do |r|
-                terminal.say r[:context]
-                terminal.say r[:command]
-                terminal.say "Body: #{terminal.path(r[:body_file])}"
+              results = project.integrate!(iteration, lanes: lane_names, teardown: teardown)
+              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]})"
+                  end
+                end
+              else
+                results.each do |r|
+                  terminal.say "Merged #{r[:lane]} → #{r[:integration_branch]} (#{r[:merge_sha][0, 8]})"
+                end
+                terminal.say "Gates NOT run — run `architect gate #{iteration}`; the verdict is the next session's."
               end
               CLI.record_outcome(Outcome.new(exit_code: 0))
             end
@@ -412,6 +457,7 @@ module Space::Architect
 
       class Gate < BaseCommand
         desc "Run the frozen Acceptance Criteria gate commands and report PASS/FAIL"
+        phase 32, "Judge"
         argument :iteration, required: true,  desc: "Iteration name"
         argument :lane,      required: false, desc: "Run in a lane worktree (default: the integration repo)"
         argument :space,     required: false, desc: "Space identifier (default: $PWD)"
@@ -439,8 +485,33 @@ module Space::Architect
         end
       end
 
+      class BugReport < BaseCommand
+        desc "Generate a prefilled GitHub issue template for filing bugs against space-architect"
+        phase 54, "Project"
+
+        def call(**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
+            )
+            terminal.say "Fill the placeholders in #{terminal.path(result[:body_path].to_s)}, then run:"
+            terminal.say result[:command]
+            terminal.say ""
+            terminal.say "Diagnostics:"
+            terminal.say "  space-architect #{Space::Core::VERSION}"
+            terminal.say "  ruby #{RUBY_VERSION} (#{RUBY_PLATFORM})"
+            terminal.say "  space: #{space.id} — #{space.title}" if space
+            CLI.record_outcome(Outcome.new(exit_code: 0))
+          end
+        end
+      end
+
       class InstallSkills < BaseCommand
         desc "Install bundled skills (architect, architect-research, architect-vocabulary) for a harness"
+        phase 53, "Project"
         option :provider, default: "claude", desc: "Harness: claude, codex, opencode, pi"
         option :project, type: :boolean, default: false, desc: "Install to CWD instead of global"
         option :force,   type: :boolean, default: false, desc: "Overwrite existing skills that differ"
@@ -640,21 +711,26 @@ module Space::Architect
   end
 end
 
+# Loop-phase declarations above sort the architect help listing; its namespaces
+# (brief/worktree/variant/research) declare no phase and list under this header.
+Space::Core::CLI::Help.trailing_group_label = "Groups"
+
 Space::Architect::CLI::Registry.register "init",   Space::Architect::CLI::Architect::Init
 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 "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
 Space::Architect::CLI::Registry.register "dispatch", Space::Architect::CLI::Architect::Dispatch
 Space::Architect::CLI::Registry.register "section",   Space::Architect::CLI::Architect::Section
 Space::Architect::CLI::Registry.register "verdict",   Space::Architect::CLI::Architect::Verdict
 Space::Architect::CLI::Registry.register "evidence",  Space::Architect::CLI::Architect::Evidence
 Space::Architect::CLI::Registry.register "merge",     Space::Architect::CLI::Architect::Merge
 Space::Architect::CLI::Registry.register "integrate", Space::Architect::CLI::Architect::Integrate
-Space::Architect::CLI::Registry.register "land",      Space::Architect::CLI::Architect::Land
 Space::Architect::CLI::Registry.register "gate",      Space::Architect::CLI::Architect::Gate
 Space::Architect::CLI::Registry.register "install-skills", Space::Architect::CLI::Architect::InstallSkills
+Space::Architect::CLI::Registry.register "bug-report",     Space::Architect::CLI::Architect::BugReport
 Space::Architect::CLI::Registry.register "brief" do |b|
   b.register "new", Space::Architect::CLI::Architect::Brief::New
 end

data/lib/space_architect/harness.rb

@@ -56,7 +56,12 @@ module Space::Architect
 
       TIMEOUT_EXIT_CODE = 124
 
-      def run(prompt_path:, run_log_path:, chdir:, push_url: nil, push_token: nil, push_client: nil, timeout: nil)
+      # 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.
+      LIVENESS_DELAY_SECONDS = 5.0
+
+      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)
         run_log_path = Pathname.new(run_log_path)
 
@@ -66,7 +71,7 @@ module Space::Architect
             Sync do
               child = Async::Process::Child.new(*argv, chdir: chdir.to_s, in: prompt_io, out: w, err: log)
               w.close
-              tasks = start_tee(r, log, push_url: push_url, push_token: push_token, push_client: push_client)
+              tasks = start_tee(r, log, push_url: push_url, push_token: push_token, push_client: push_client, err: err)
               timed_out    = false
               timeout_task = nil
 
@@ -84,8 +89,21 @@ 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_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)
+                end
+              end
+
               status = child.wait
               timeout_task&.stop
+              liveness_task&.stop
 
               tasks.each(&:wait)
               timed_out ? TIMEOUT_EXIT_CODE : status.exitstatus
@@ -113,6 +131,42 @@ module Space::Architect
 
       private
 
+      # 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)
+        bytes = run_log_path.exist? ? run_log_path.size : 0
+        if bytes.zero?
+          err.puts "liveness: WARN no growth — run log still empty #{delay}s after dispatch"
+          return
+        end
+
+        streamed = streamed_init_model(run_log_path)
+        if streamed.nil?
+          err.puts "liveness: WARN model unverified — no stream-json init event after #{delay}s (run log #{bytes} bytes)"
+        elsif streamed == @model
+          err.puts "liveness: OK streaming model=#{streamed} (run log growing, #{bytes} bytes)"
+        else
+          err.puts "liveness: WARN model mismatch — pinned=#{@model} streamed=#{streamed} (run log growing, #{bytes} bytes)"
+        end
+      rescue StandardError
+        # 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
         args = [
           @bin, "-p",
@@ -128,17 +182,17 @@ module Space::Architect
         args
       end
 
-      def start_tee(r, log, push_url:, push_token:, push_client:)
+      def start_tee(r, log, push_url:, push_token:, push_client:, err: $stderr)
         if push_url || push_client
           body = Protocol::HTTP::Body::Writable.new(queue: Thread::SizedQueue.new(32))
-          push = Async { push_body(body, push_url: push_url, push_token: push_token, push_client: push_client) }
-          [Async { tee_pipe(r, log, body) }, push]
+          push = Async { push_body(body, push_url: push_url, push_token: push_token, push_client: push_client, err: err) }
+          [Async { tee_pipe(r, log, body, err: err) }, push]
         else
           [Async { drain_pipe(r, log) }]
         end
       end
 
-      def push_body(body, push_url:, push_token:, push_client:)
+      def push_body(body, push_url:, push_token:, push_client:, err: $stderr)
         path    = push_url ? URI.parse(push_url).path : "/"
         headers = [["content-type", "application/x-ndjson"]]
         headers << ["authorization", "Bearer #{push_token}"] if push_token
@@ -150,10 +204,10 @@ module Space::Architect
           end
         end
       rescue StandardError => e
-        $stderr.puts "push_body: transport error (best-effort, run log intact): #{e.class}: #{e.message}"
+        err.puts "push_body: transport error (best-effort, run log intact): #{e.class}: #{e.message}"
       end
 
-      def tee_pipe(r, log, body)
+      def tee_pipe(r, log, body, err: $stderr)
         pushing = true
         while (chunk = r.gets)
           log.write(chunk)
@@ -162,7 +216,7 @@ module Space::Architect
             begin
               body.write(chunk)
             rescue StandardError => e
-              $stderr.puts "tee_pipe: push write failed (best-effort, continuing log): #{e.class}: #{e.message}"
+              err.puts "tee_pipe: push write failed (best-effort, continuing log): #{e.class}: #{e.message}"
               pushing = false
             end
           end

data/lib/space_architect/templates/iteration.md.erb

@@ -27,9 +27,23 @@ Write + commit: `architect section <%= @_name %> specification --from <file>`. -
 - **Boundaries** — may-touch / must-not-touch / out-of-scope; no placeholders;
   no refactors beyond the task. (Frozen stack: cite `BRIEF §2`.)
 - **Lane plan** — 1–4 lanes, each declaring: target repo `repos/<repo>`,
-  file-touch set (overlap-checked), objective, output format, boundaries.
+  file-touch set (overlap-checked), objective, output format, boundaries. The
+  machine-readable declaration lives in the fenced ```lanes block below — the single
+  frozen source of truth `architect freeze` records and `architect provision`
+  materializes.
 - **Effort** — `think hard` … `ultrathink` per lane, with one line of why.
 
+```lanes
+# One entry per lane (1–4). The frozen out-of-bounds contract: `architect freeze`
+# writes each into space.yaml (name, repo, touch_set); `architect provision <%= @_name %>`
+# materializes the worktrees + lane branches. Remove the comment markers to activate.
+# - name: lane-a            # lane name (required)
+#   repo: my-repo           # target repo under repos/ (required)
+#   touch:                  # file globs this lane may write (required, non-empty)
+#     - lib/my_repo/**
+#     - test/my_repo_test.rb
+```
+
 ## Acceptance Criteria
 
 <!-- PROOF. Write the prose conditions of correctness (AC1, AC2, …) that the

data/lib/space_architect.rb

@@ -10,5 +10,6 @@ require_relative "space_architect/gate_lint"
 require_relative "space_architect/gate_evaluator"
 require_relative "space_architect/architect_project"
 require_relative "space_architect/skill_installer"
+require_relative "space_architect/bug_report"
 require_relative "space_architect/research"
 require_relative "space_architect/cli"

data/lib/space_core/cli/help.rb

@@ -2,6 +2,7 @@
 
 require "dry/cli"
 require "pastel"
+require_relative "loop_status"
 
 module Space::Core::CLI
   # Colourful replacement for dry-cli's plain `Usage` listing — the "global
@@ -27,17 +28,30 @@ module Space::Core::CLI
 
     module_function
 
-    def call(result, pastel: CLI.help_pastel)
-      rows  = listing(result)
-      width = rows.map { |label, _| label.length }.max || 0
+    # Header for the trailing group of children that declare no phase. Left nil
+    # for the `space` binary (whose commands are all phase-less → one ungrouped
+    # listing); the `architect` binary sets it so its namespaces list under a
+    # "Groups" header. Keeps phase vocabulary out of this generic renderer.
+    def self.trailing_group_label = @trailing_group_label
+
+    def self.trailing_group_label=(label)
+      @trailing_group_label = label
+    end
 
-      lines = rows.map do |label, description|
-        painted = pastel.cyan(label.ljust(width))
-        description ? "  #{painted}   #{pastel.dim("# #{description}")}" : "  #{painted}"
+    def call(result, pastel: CLI.help_pastel)
+      groups = grouped_listing(result)
+      width  = groups.flat_map { |_h, rows| rows.map { |label, _| label.length } }.max || 0
+
+      body = groups.flat_map do |group_header, rows|
+        lines = rows.map do |label, description|
+          painted = pastel.cyan(label.ljust(width))
+          description ? "  #{painted}   #{pastel.dim("# #{description}")}" : "  #{painted}"
+        end
+        group_header ? ["", pastel.bold(group_header), *lines] : lines
       end
 
-      [header(result, pastel), pastel.bold("Commands:"), *lines, footer(result, pastel)]
-        .compact.join("\n")
+      [header(result, pastel), pastel.bold("Commands:"), *body,
+       footer(result, pastel), loop_status_block(result, pastel)].compact.join("\n")
     end
 
     # The richer header only makes sense at the true root (`space` / `architect`),
@@ -69,13 +83,66 @@ module Space::Core::CLI
       [prog, *names].join(" ")
     end
 
-    # [[label_with_banner, description_or_nil], ...] sorted by command name.
-    def listing(result)
-      result.children.sort_by { |name, _| name }.filter_map do |name, node|
-        next if node.hidden
+    # Group non-hidden children into an ordered list of [header_or_nil, rows].
+    # When no child declares a phase (e.g. the `space` binary), returns a single
+    # unlabelled group sorted by name — byte-identical to the pre-phase listing.
+    # Otherwise groups declared commands under their phase label (groups, and
+    # members within a group, ordered by the declared order), with undeclared
+    # children (namespaces) trailing in the default group.
+    def grouped_listing(result)
+      decorated = result.children.filter_map do |name, node|
+        [name, node, phase_of(node)] unless node.hidden
+      end
+
+      if decorated.all? { |_name, _node, phase| phase.nil? }
+        rows = decorated.sort_by { |name, _node, _phase| name }
+                        .map { |name, node, _phase| row(result, name, node) }
+        return [[nil, rows]]
+      end
 
-        [label(result, name, node), description(node)]
+      phased, unphased = decorated.partition { |_name, _node, phase| phase }
+      groups = phased.group_by { |_name, _node, phase| phase.last }
+      listing = groups.sort_by { |_label, members| members.map { |_n, _node, phase| phase.first }.min }
+                      .map do |label, members|
+        rows = members.sort_by { |_n, _node, phase| phase.first }
+                      .map { |name, node, _phase| row(result, name, node) }
+        [label, rows]
       end
+      listing << [trailing_group_label, unphased.map { |name, node, _phase| row(result, name, node) }] \
+        unless unphased.empty?
+      listing
+    end
+
+    def row(result, name, node)
+      [label(result, name, node), description(node)]
+    end
+
+    def phase_of(node)
+      node.command.respond_to?(:phase) ? node.command.phase : nil
+    end
+
+    # Opportunistic, TOTAL loop-status embed: only the architect binary's ROOT
+    # listing gets it. Resolves the current space best-effort and renders the
+    # shared block from that space's own space.yaml `project` data (no
+    # space_architect dependency). ANY failure — no space, store failure,
+    # malformed yaml, no `project` block — omits the block; help always renders.
+    def loop_status_block(result, pastel)
+      return unless result.names.empty? && File.basename($PROGRAM_NAME) == "architect"
+
+      project = current_space_project
+      lines = project && LoopStatus.lines(project)
+      return if lines.nil? || lines.empty?
+
+      ["", pastel.bold("Loop:"), *lines.map { |l| "  #{pastel.dim(l)}" }].join("\n")
+    rescue StandardError
+      nil
+    end
+
+    def current_space_project
+      store = Space::Core::SpaceStore.new(config: Space::Core::Config.load, state: Space::Core::State.load)
+      store.current.value_or(nil)&.data&.[]("project")
+    rescue StandardError
+      nil
     end
 
     def label(result, name, node)
@@ -109,15 +176,18 @@ module Space::Core::CLI
 end
 
 # Route dry-cli's plain namespace/root listing through our colourful renderer.
-# We replace Usage.call wholesale and depend only on the LookupResult/Node API
-# (children, command, leaf?/children?/hidden, names) rather than copying Usage's
-# internals — see notes/ruby-cli-gems-report.md.
+# We prepend over Usage.call wholesale and depend only on the LookupResult/Node
+# API (children, command, leaf?/children?/hidden, names) rather than copying
+# Usage's internals — see notes/ruby-cli-gems-report.md.
 module Dry
   class CLI
     module Usage
-      def self.call(result)
-        Space::Core::CLI::Help.call(result)
+      module ColourPatch
+        def call(result)
+          Space::Core::CLI::Help.call(result)
+        end
       end
+      singleton_class.prepend(ColourPatch)
     end
   end
 end

data/lib/space_core/cli/loop_status.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Space::Core::CLI
+  # Compact Architect-Loop status block, derived from a space's own `project`
+  # block in space.yaml — so this carries NO dependency on space_architect. It
+  # is shared by the `architect --help` embed and the `space status` report.
+  # Returns plain lines (callers colourise) and never raises on malformed data.
+  module LoopStatus
+    module_function
+
+    # Lines for the compact block, or nil when there is no `project` block.
+    def lines(project)
+      return nil unless project.is_a?(Hash) && !project.empty?
+
+      rows = ["Project status:  #{project["status"] || "(none)"}"]
+      iter = current_iteration(project)
+      rows << "Iteration:       #{ordinal(iter)} #{iter["name"]} — #{state_of(iter)}" if iter
+      rows
+    end
+
+    def current_iteration(project)
+      name = project["current_iteration"]
+      return nil unless name
+
+      Array(project["iterations"]).find { |s| s["name"] == name }
+    end
+
+    def ordinal(iter)
+      iter["ordinal"] ? format("I%02d", iter["ordinal"]) : "I--"
+    end
+
+    # Derived loop state for the current iteration. Mirrors the precedence in
+    # `architect status`: a decided verdict wins, then an integrated lane
+    # (awaiting-verdict), then dispatched lanes, then a bare freeze, else spec.
+    def state_of(iter)
+      verdict = iter["verdict"]
+      return verdict if verdict && verdict != "pending"
+
+      lanes = Array(iter["lanes"])
+      return "awaiting-verdict" if lanes.any? { |l| l["integration_branch"] }
+      return "dispatched" if lanes.any?
+      return "frozen #{iter["freeze_sha"][0, 8]}" if iter["freeze_sha"]
+
+      "speccing"
+    end
+  end
+end