space-architect 2.0.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ded62e199397e162bba1ff6ee37a5c6a9c7ee83a446d154107036aa4d628768
-  data.tar.gz: 592a6bb0c3b10b2773873e7fc3fd79cf7197bad78ada5520c5c9dc77e60aae2f
+  metadata.gz: 135a6282cfe3e3073265b71867e7d228673cbfb9b7253feaaba5ad67a180b7cb
+  data.tar.gz: 0d0406a99feadadebb24a6167c11837de25bede933e752ef6507524208f4e5a7
 SHA512:
-  metadata.gz: 91b5a865cb40557085399853e723e7763c2a54cb183d95b9744f9886753579aa841309f3f2dc490d28a3ad10d4693db06cfb615a9716b2b13fe68ded86b932f6
-  data.tar.gz: 6ebb0c24e6e603252aab77da49ff2b904d22084e0c840f7d46d5ac0eb66ec7c315ec04816d6446dc537cac5b3dbc58c7663d8bbbb563443566cd6e84de5ee05a
+  metadata.gz: c8b161eff4f4b5a788c2e3c9b423bcc31a495915a076afb70445f6b0cdaf1cc2573ee381ce0c3e09ca712a8398b70ca091b015260b6b4e9c24914ece4a0f5539
+  data.tar.gz: f61cdd897881530ad2e81df5bd846c4e644fb85ac6847c4afd147e643b6045b59c7ecb89fd12b83f9a7b5c2ef12813c5e88e7634449a919aac2e4bc75052a6b0

data/CHANGELOG.md

@@ -5,6 +5,49 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.0.0] - 2026-07-01
+
+### Added
+
+- **`architect bug-report`** — zero-friction bug-filing command. Gathers
+  diagnostics (gem version, Ruby version/platform, and when run inside a space:
+  space id, title, and iteration list with verdicts), writes a prefilled GitHub
+  issue-body template to `<space>/build/bug-report/architect-bug-report-YYYYMMDD-HHMMSS.md`
+  (or `./architect-bug-report-YYYYMMDD-HHMMSS.md` outside a space — timestamped so
+  back-to-back runs in the same session never overwrite each other), and prints —
+  never executes — the `gh issue create -R jetpks/space-architect` invocation to run.
+
+### Removed
+
+- **BREAKING — `architect land` removed** (added in 2.0.0) — landing is the architect
+  skill's procedure: the architect writes the PR body and presents the push +
+  PR command. The command as shipped never produced a runnable block (#25) and
+  authored content the CLI has no context for (#24).
+
+### Fixed
+
+- **`architect bug-report` — `~`-contracted paths in printed commands.**
+  The `gh issue create` invocation printed to stdout renders the
+  `--body-file` path as `~/…` instead of the user's expanded `$HOME`.
+  `Space::Core::Paths.contract` is the single home-contraction helper; `Terminal#path`
+  delegates to it.
+- **Command wrapping for narrow terminals.** The `gh issue create` command is
+  now rendered with trailing ` \` continuations broken at `--flag` boundaries,
+  continuation lines indented two spaces. The wrapped output is valid shell
+  (`bash -n` clean). `Space::Core::Commands.wrap` is the single wrapping helper.
+
+## [2.0.2] - 2026-07-01
+
+### Added
+
+- **Declarative runtime env forwarding for `space run`.** A space can declare
+  `run.env:` in `space.yaml` — a list of host env vars forwarded into the
+  container as bare `-e VAR` passthrough (value never lands in argv/`ps`), on top
+  of the always-on substrate auth vars. `space run --env VAR` (repeatable) adds
+  more ad hoc. A requested-but-unset var warns on stderr instead of failing
+  opaquely in-guest. This lets credentialed payloads (e.g. a Fireworks/OpenAI key)
+  run via a plain `space run <cmd>` with no wall of flags, without baking secrets.
+
 ## [2.0.1] - 2026-07-01
 
 Fast-follow completing the `pack.persist:` story from 2.0.0.
@@ -316,6 +359,7 @@ the **BREAKING** items under Changed. The repository is now a monorepo; the
   lanes, worktrees, and headless `claude -p` dispatch, with variant sets and the
   claude-code and opencode harnesses.
 
+[2.0.2]: https://github.com/jetpks/space-architect/compare/v2.0.1...v2.0.2
 [2.0.1]: https://github.com/jetpks/space-architect/compare/v2.0.0...v2.0.1
 [2.0.0]: https://github.com/jetpks/space-architect/compare/v1.3.0...v2.0.0
 [1.3.0]: https://github.com/jetpks/space-architect/compare/v1.2.0...v1.3.0

data/README.md

@@ -158,6 +158,19 @@ variables that are actually set — `ANTHROPIC_API_KEY`, `CLAUDE_CODE_OAUTH_TOKE
 `ANTHROPIC_BASE_URL` — with `-e` at run time, so credentials live in your shell,
 never in the image. 🗝️
 
+**Forwarding payload credentials.** Beyond the always-on auth trio, a space can declare
+`run.env:` in `space.yaml` — a list of host env var names forwarded into the container at
+run time. You can also pass `space run --env VAR` (repeatable) for ad hoc additions. All
+forwarding is bare `-e VAR` passthrough: values never appear in argv, `ps`, or the image.
+A requested-but-unset var warns on stderr instead of silently failing inside the guest.
+
+```yaml
+run:
+  env:                         # run-time: host var names, forwarded as bare -e VAR
+    - FIREWORKS_API_KEY
+    - OPENAI_API_KEY
+```
+
 **Declaring provisioning & persistence** — two optional keys in `space.yaml`:
 
 ```yaml
@@ -169,10 +182,19 @@ pack:
     - /root/.local/state
 ```
 
-`provision` scripts must live under the space root and run as `RUN /space/<script>`
-while the image builds. `persist` paths must be absolute; `space run` bind-mounts
-each one from `<space>/.state<path>` on the host (created on first run) so a
-container's mutable state survives across runs. Both are validated at pack time.
+`provision` scripts must live under the space root and be executable. Each script is
+copied into the image individually (`COPY <script> /space/<script>`) and then invoked
+(`RUN /space/<script>`) **before** the full space tree lands and **before** the gem is
+installed. This ordering is the cache-hygiene guarantee: editing any other space file
+leaves the provision and gem-install layers cached, so a rebuild completes in seconds
+instead of minutes. Scripts must therefore be self-contained — they run with only the
+base system layers and any earlier provision scripts' outputs; they cannot read other
+space files or call `architect`/`space`. Scripts must have the executable bit set; COPY
+preserves the mode from the build context.
+
+`persist` paths must be absolute; `space run` bind-mounts each one from
+`<space>/.state<path>` on the host (created on first run) so a container's mutable state
+survives across runs. Both are validated at pack time.
 
 Like everything else, these are reachable as `architect space pack|build|run`
 from inside a project.
@@ -280,7 +302,7 @@ architect evidence <it> --lane <lane>       # transcribe the builder's report ve
 architect gate <iteration>                  # run the frozen gate commands, stream raw output
 architect merge <it> <lane>                 # integrate ONE judged-passing lane (--no-ff)
 architect integrate <it> --lanes a,b        # integrate a set of passing lanes, in order
-architect land                              # end-of-project PR command (no push, no gh)
+# landing (PR body + push/PR command) is the architect's end-of-project procedure (see skill)
 architect status                            # project state (read-only)
 architect variant add|compare|promote …     # competing (harness, model) lanes over one frozen spec
 architect research dispatch|status|wait …   # parallel read-only research lanes (see below)
@@ -299,7 +321,7 @@ architect evidence my-feature --lane lane-a      # transcribe raw evidence
 architect gate my-feature                        # run the frozen gates yourself
 # … read the diff against the spec, then write the Verdict …
 architect integrate my-feature --lanes lane-a    # merge passing lanes → project/<slug>
-architect land                                   # print gh pr create at project end
+# landing (PR body + push/PR command) is the architect's end-of-project procedure (see skill)
 ```
 
 ### Streaming builder output 📡

data/lib/space_architect/architect_project.rb

@@ -415,43 +415,6 @@ module Space::Architect
       merged
     end
 
-    # Generate the end-of-project PR command(s) for each integrated repo.
-    # Writes a PR body to build/land/<repo>-pr-body.md and returns, per repo:
-    # { repo:, integration_branch:, body_file:, command:, context: }.
-    # Raises Space::Core::Error if nothing has been integrated yet.
-    # Side-effect-free: no git write, no push, no gh.
-    def land
-      b = space.data["project"] || {}
-      integration_branch = project_integration_branch
-
-      integrated_lanes = (b["iterations"] || []).flat_map do |s|
-        (s["lanes"] || []).filter_map { |l| { iteration: s, lane: l } if l["integration_branch"] }
-      end
-
-      raise Space::Core::Error, "nothing integrated yet — integrate a lane before landing" if integrated_lanes.empty?
-
-      repos = integrated_lanes.map { |e| e[:lane]["repo"] }.uniq
-
-      repos.map do |repo|
-        body_dir = space.path.join("build", "land")
-        FileUtils.mkdir_p(body_dir)
-        body_path = body_dir.join("#{repo}-pr-body.md")
-
-        iterations = b["iterations"] || []
-        body = +"# #{space.title}\n\nMerges `#{integration_branch}` → `main`.\n\n## Iterations\n\n"
-        iterations.each do |s|
-          nn = format("%02d", s["ordinal"])
-          verdict = s["verdict"] || "—"
-          body << "- I#{nn} #{s["name"]} — #{verdict}\n"
-        end
-        body_path.write(body)
-
-        cmd = %(gh pr create --base main --head #{integration_branch} --title "#{space.title}" --body-file #{body_path})
-        context = "# Run from repos/#{repo} on branch #{integration_branch} (gh pushes it)"
-        { repo: repo, integration_branch: integration_branch, body_file: body_path.to_s, command: cmd, context: context }
-      end
-    end
-
     # Run the iteration's frozen Acceptance Criteria gate commands. Each gate is
     # executed in the resolved cwd (per-gate `cwd` overrides the base dir), under
     # a hard timeout, and evaluated against its `expect` block. Returns an array

data/lib/space_architect/bug_report.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+
+module Space
+  module Architect
+    module BugReport
+      REPO = "jetpks/space-architect"
+
+      class << self
+        def generate(space: nil, env: ENV, cwd: Dir.pwd, now: Time.now)
+          body_path = resolve_body_path(space, cwd, now)
+          FileUtils.mkdir_p(body_path.dirname)
+          body = build_body(space)
+          body_path.write(body)
+          contracted = Space::Core::Paths.contract(body_path, env: env)
+          command = Space::Core::Commands.wrap(
+            %(gh issue create -R #{REPO} --title "<one-line summary>" --body-file #{contracted})
+          )
+          { body_path: body_path, command: command, body: body }
+        end
+
+        private
+
+        def resolve_body_path(space, cwd, now)
+          filename = "architect-bug-report-#{now.strftime('%Y%m%d-%H%M%S')}.md"
+          if space
+            space.path.join("build", "bug-report", filename)
+          else
+            Pathname.new(cwd).join(filename)
+          end
+        end
+
+        def build_body(space)
+          body = +template_header
+          body << diagnostics_section
+          body << space_section(space) if space
+          body
+        end
+
+        def template_header
+          <<~MD
+            <!-- Title: <one-line summary> -->
+
+            **Kind:** <!-- process / tooling / both -->
+
+            ## Summary
+
+            <!-- One sentence describing the bug. -->
+
+            ## What happened
+
+            <!-- Describe what you observed. -->
+
+            ## What was expected
+
+            <!-- Describe what you expected to happen. -->
+
+            ## Repro steps
+
+            <!-- Numbered steps to reproduce. -->
+
+          MD
+        end
+
+        def diagnostics_section
+          <<~MD
+            ## Diagnostics
+
+            - space-architect: #{Space::Core::VERSION}
+            - ruby: #{RUBY_VERSION} (#{RUBY_PLATFORM})
+          MD
+        end
+
+        def space_section(space)
+          iterations = Array(space.data.dig("project", "iterations"))
+          iter_lines = iterations.map do |s|
+            nn = format("%02d", s["ordinal"])
+            verdict = s["verdict"] || "—"
+            "- I#{nn} #{s["name"]} — #{verdict}"
+          end.join("\n")
+
+          +"\n## Space context\n\n" \
+            "- Space id: #{space.id}\n" \
+            "- Space title: #{space.title}\n" \
+            "\n### Iterations\n\n" \
+            "#{iter_lines.empty? ? "(none)" : iter_lines}\n"
+        end
+      end
+    end
+  end
+end

data/lib/space_architect/cli/architect.rb

@@ -389,27 +389,6 @@ module Space::Architect
         end
       end
 
-      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])}"
-              end
-              CLI.record_outcome(Outcome.new(exit_code: 0))
-            end
-          end
-        end
-      end
-
       class Gate < BaseCommand
         desc "Run the frozen Acceptance Criteria gate commands and report PASS/FAIL"
         argument :iteration, required: true,  desc: "Iteration name"
@@ -439,6 +418,29 @@ module Space::Architect
         end
       end
 
+      class BugReport < BaseCommand
+        desc "Generate a prefilled GitHub issue template for filing bugs against space-architect"
+
+        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"
         option :provider, default: "claude", desc: "Harness: claude, codex, opencode, pi"
@@ -652,9 +654,9 @@ Space::Architect::CLI::Registry.register "verdict",   Space::Architect::CLI::Arc
 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.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/run.rb

@@ -9,21 +9,35 @@ class Run < BaseCommand
 
   argument :command, type: :array, required: false, desc: "Command to run in the container (default: login shell)"
   option :tty, type: :boolean, default: nil, desc: "Force interactive TTY (default: auto-detect)"
+  option :env, type: :array, desc: "Host env var to forward into the container (repeatable; adds to run.env)"
 
-  def call(command: [], tty: nil, **opts)
+  def call(command: [], tty: nil, env: [], **opts)
     setup_terminal(**opts.slice(:color, :colors))
     handle_errors do
       result = store.current.bind do |space|
-        runner = Space::Core::OciRunner.new(space: space, interactive: tty.nil? ? CLI.tty?(out) : tty)
+        runner = Space::Core::OciRunner.new(
+          space: space, interactive: tty.nil? ? CLI.tty?(out) : tty, env_vars: env
+        )
         runner.command(command).fmap { |argv| { argv: argv, runner: runner } }
       end
       render(result) do |r|
         r[:runner].host_dirs.each { |d| FileUtils.mkdir_p(d) }
+        warn_missing_env(r[:runner].missing_env)
         terminal.say "Running: #{r[:argv].join(' ')}"
         out.flush # Kernel.exec replaces the process without flushing buffered IO
         Kernel.exec(*r[:argv])
       end
     end
   end
+
+  private
+
+  # A requested var absent from the host env is almost always a forgotten export;
+  # forwarding silently omits it and the payload fails opaquely in-guest. Warn, don't fail.
+  def warn_missing_env(missing)
+    return if missing.empty?
+
+    terminal.error("Warning: requested env not set on host, not forwarded: #{missing.join(', ')}")
+  end
 end
 end

data/lib/space_core/commands.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Space::Core
+  module Commands
+    module_function
+
+    # Render a multi-flag command with trailing " \" continuations broken at
+    # "--flag" boundaries, continuation lines indented two spaces. Commands
+    # without "--" flags are returned unchanged.
+    def wrap(command)
+      parts = command.split(/(?= --)/)
+      return command if parts.size <= 1
+
+      parts.each_with_index.map do |part, i|
+        segment = i.zero? ? part.rstrip : "  #{part.lstrip}"
+        i < parts.size - 1 ? "#{segment} \\" : segment
+      end.join("\n")
+    end
+  end
+end

data/lib/space_core/oci_packer.rb

@@ -84,6 +84,10 @@ module Space::Core
       [entrypoint_content].pack("m0")
     end
 
+    def local_space_architect?
+      space.path.join("repos/space-architect").directory?
+    end
+
     def render_template(name)
       template_path = TEMPLATE_DIR.join(name)
       ERB.new(template_path.read, trim_mode: "-").result(binding)

data/lib/space_core/oci_runner.rb

@@ -7,12 +7,15 @@ module Space::Core
   class OciRunner
     include Dry::Monads[:result]
 
+    # Always-forwarded substrate auth (the in-image architect/claude reach for these).
+    # Payload-specific vars are declared per-space via `run.env:` or the --env flag.
     AUTH_ENV = %w[ANTHROPIC_API_KEY CLAUDE_CODE_OAUTH_TOKEN ANTHROPIC_BASE_URL].freeze
 
-    def initialize(space:, env: ENV.to_h, interactive: true)
+    def initialize(space:, env: ENV.to_h, interactive: true, env_vars: [])
       @space = space
       @env = env
       @interactive = interactive
+      @env_vars = (space.run_env + Array(env_vars)).map(&:to_s)
     end
 
     def image
@@ -36,7 +39,7 @@ module Space::Core
       argv = [
         "container", "run", "--rm",
         *(@interactive ? ["-i", "-t"] : []),
-        *auth_flags,
+        *env_flags,
         *mount_flags,
         image,
         *extra
@@ -44,17 +47,30 @@ module Space::Core
       Success(argv)
     end
 
+    # Explicitly-requested vars (run.env: + --env) that are unset/empty in the host
+    # env, so the caller can warn — silence here would let a missing key fail opaquely
+    # inside the guest. AUTH_ENV is opportunistic and intentionally excluded.
+    def missing_env
+      @env_vars.uniq.reject { |var| present?(var) }
+    end
+
     private
 
     attr_reader :space, :env, :interactive
 
-    def auth_flags
-      AUTH_ENV.each_with_object([]) do |var, flags|
-        val = env[var]
-        flags.push("-e", var) if val && !val.empty?
+    # Bare `-e VAR` passthrough (no =value on the command line, so the secret never
+    # lands in argv/ps): substrate auth first, then the space's declared payload vars.
+    def env_flags
+      (AUTH_ENV + @env_vars).uniq.each_with_object([]) do |var, flags|
+        flags.push("-e", var) if present?(var)
       end
     end
 
+    def present?(var)
+      val = env[var]
+      val && !val.empty?
+    end
+
     def mount_flags
       mounts.each_with_object([]) do |(host, guest), flags|
         flags.push("-v", "#{host}:#{guest}")

data/lib/space_core/paths.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Space::Core
+  module Paths
+    module_function
+
+    def contract(path, env: ENV)
+      value = path.to_s
+      home  = XDG.home(env: env)
+      [home, realpath_or_nil(home)].compact.uniq.each do |h|
+        return "~"  if value == h
+        return "~#{value.delete_prefix(h)}" if value.start_with?("#{h}/")
+      end
+      value
+    end
+
+    def realpath_or_nil(path)
+      File.realpath(path)
+    rescue SystemCallError
+      nil
+    end
+  end
+end

data/lib/space_core/space.rb

@@ -56,6 +56,12 @@ module Space::Core
       Array(data.dig("pack", "persist")).map(&:to_s)
     end
 
+    # Host env vars to forward into the container at `space run` (bare passthrough).
+    # Declared per-space so payloads needing credentials run without a wall of flags.
+    def run_env
+      Array(data.dig("run", "env")).map(&:to_s)
+    end
+
     def architect
       data["project"]
     end

data/lib/space_core/templates/oci/dockerfile.erb

@@ -30,18 +30,6 @@ RUN apt-get update -qq \
 # Claude Code CLI (https://claude.ai/install.sh)
 RUN curl -fsSL https://claude.ai/install.sh | bash
 
-# Copy the space tree into the image (filtered by Dockerfile.dockerignore alongside this Dockerfile)
-COPY . /space
-
-# Install space-architect gem: prefer in-space checkout for a pinned version, fall back to RubyGems
-RUN if [ -d /space/repos/space-architect ]; then \
-      cd /space/repos/space-architect \
-   && rake build \
-   && gem install --no-document pkg/*.gem; \
-    else \
-      gem install --no-document space-architect; \
-    fi
-
 # Write entrypoint: sets git safe.directory, execs requested command or a login shell
 RUN echo '<%= entrypoint_b64 %>' | base64 -d > /entrypoint.sh \
  && chmod +x /entrypoint.sh
@@ -52,10 +40,25 @@ RUN printf 'export PATH="/usr/local/bundle/bin:/root/.local/bin:$PATH"\n' \
 <% if provision_scripts.any? -%>
 
 # Space-declared build-time provisioning (pack.provision)
+# Each script is COPY'd individually — a space-content edit elsewhere does not bust its cache layer.
 <% provision_scripts.each do |script| -%>
+COPY <%= script %> /space/<%= script %>
 RUN /space/<%= script %>
 <% end -%>
 <% end -%>
+
+# Install space-architect gem
+<% if local_space_architect? -%>
+COPY repos/space-architect /space/repos/space-architect
+RUN cd /space/repos/space-architect \
+ && rake build \
+ && gem install --no-document pkg/*.gem
+<% else -%>
+RUN gem install --no-document space-architect
+<% end -%>
+
+# Copy the space tree into the image (filtered by Dockerfile.dockerignore alongside this Dockerfile)
+COPY . /space
 <% if persist_paths.any? -%>
 
 # Seed snapshot: capture baked content of persisted dirs so a first-run (empty) mount is seeded from it

data/lib/space_core/terminal.rb

@@ -48,13 +48,7 @@ module Space::Core
     end
 
     def path(path)
-      value = path.to_s
-      homes.each do |home|
-        return "~" if value == home
-        return "~#{value.delete_prefix(home)}" if value.start_with?("#{home}/")
-      end
-
-      value
+      Paths.contract(path, env: config.env)
     end
 
     def with_spinner(message)
@@ -108,17 +102,6 @@ module Space::Core
       end
     end
 
-    def homes
-      home = XDG.home(env: config.env)
-      [home, realpath_or_nil(home)].compact.uniq
-    end
-
-    def realpath_or_nil(path)
-      File.realpath(path)
-    rescue SystemCallError
-      nil
-    end
-
     def table_row(headers, row, column_widths, header: false)
       row.each_with_index.map do |cell, index|
         raw = cell.to_s

data/lib/space_core/version.rb

@@ -2,6 +2,6 @@
 
 module Space
   module Core
-    VERSION = "2.0.1"
+    VERSION = "3.0.0"
   end
 end

data/lib/space_core.rb

@@ -10,6 +10,8 @@ require "space_core/warnings"
 Space::Core::Warnings.disable_experimental!
 require "space_core/atomic_write"
 require "space_core/xdg"
+require "space_core/paths"
+require "space_core/commands"
 require "space_core/config"
 require "space_core/state"
 require "space_core/slugger"

data/skill/architect/SKILL.md

@@ -110,6 +110,7 @@ loop.
 8. **Stop conditions:** failing verification you can't root-cause, instructions
    conflicting with project docs, irreversible/destructive calls, or scope
    growth beyond the iteration → checkpoint to the handoff and ask the human.
+   For bugs in the architect tooling or process itself, run `architect bug-report` — it prints a prefilled issue template and the `gh` command to file it.
 
 ## Procedure
 
@@ -373,10 +374,15 @@ cited BRIEF §sections (per §2), then write the **Verdict** (`architect verdict
 <iteration> continue|kill --from <file>`): disagreement rulings, per-AC
 PASS/FAIL/INVALID, the KILL/CONTINUE call.
 
-At project end, `architect land` prints the single `gh pr create --base main
---head project/<slug>` command per touched repo and writes a PR body to
-`build/land/` — no push, no `gh` call; the human runs it from the repo when
-the project is ready to ship.
+At project end, landing is yours, not the CLI's — the PR body is judgment
+output, the same class as a Verdict. Per touched repo: write the PR body
+yourself — from the iteration verdicts, the integrated diff, and the BRIEF —
+to `build/land/<repo>-pr-body.md`, then present the paste-and-run block to the
+human: `cd` to the repo checkout, `git push -u origin project/<slug>`, and
+`gh pr create --base main --head project/<slug> --title … --body-file …` —
+paths `~`-contracted, the multi-flag command broken with trailing ` \` at flag
+boundaries. No push, no `gh` call by you or the CLI; the human runs the block
+when the project is ready to ship.
 
 ## Maintenance
 

data/skill/architect/dispatch.md

@@ -112,7 +112,9 @@ lanes pass; the CLI does the git mechanics. Canonical path:
 architect integrate <iteration> --lanes <passing-set>   # e.g. --lanes lane-a,lane-b
 architect gate <iteration>                              # integration smoke (raw output; verdict stays yours)
 architect integrate <iteration> --lanes <passing-set> --teardown   # or remove worktrees + lane branches after
-architect land                                          # end of project: prints gh pr create --base main --head project/<slug>
+# end of project: landing is the architect's, not a CLI command — write the PR
+# body to build/land/<repo>-pr-body.md yourself, then present the paste-and-run
+# block (cd, git push -u origin project/<slug>, gh pr create) — see SKILL.md §6
 ```
 
 `architect integrate` commits each named lane on its branch and merges it
@@ -138,8 +140,8 @@ git -C repos/<repo> merge --no-ff lane/<iteration>-<lane>
 <run the gate commands>          # integration smoke after every merge
 architect worktree remove <iteration> <lane>
 git -C repos/<repo> branch -d lane/<iteration>-<lane>
-# at project end:
-architect land                   # prints gh pr create --base main --head project/<slug>
+# at project end there is no CLI step: the architect writes
+# build/land/<repo>-pr-body.md and presents the push + gh pr create block
 ```
 
 ### Parallel + fast-follow

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: space-architect
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Eric Jacobs
@@ -240,6 +240,7 @@ files:
 - exe/src
 - lib/space_architect.rb
 - lib/space_architect/architect_project.rb
+- lib/space_architect/bug_report.rb
 - lib/space_architect/cli.rb
 - lib/space_architect/cli/architect.rb
 - lib/space_architect/cli/research.rb
@@ -281,6 +282,7 @@ files:
 - lib/space_core/cli/show.rb
 - lib/space_core/cli/status.rb
 - lib/space_core/cli/use.rb
+- lib/space_core/commands.rb
 - lib/space_core/config.rb
 - lib/space_core/errors.rb
 - lib/space_core/git_client.rb
@@ -288,6 +290,7 @@ files:
 - lib/space_core/oci_builder.rb
 - lib/space_core/oci_packer.rb
 - lib/space_core/oci_runner.rb
+- lib/space_core/paths.rb
 - lib/space_core/repo_reference.rb
 - lib/space_core/repo_resolver.rb
 - lib/space_core/shell_integration.rb