space-architect 8.0.0 → 9.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b63abfece4c105ef5b2befd0d8c4e4301d8d5cade10570cd2f41bd0641b8c4be
-  data.tar.gz: 6b932ae13952dad48f81a2ee68ed52b7cee28ef8edc4a99e7a06f23952c4f107
+  metadata.gz: 02caeb5cc690ab3d847e54fed5eb88c1493fa2402ace662ef7f25d2aeb4d055b
+  data.tar.gz: 5fa1fc73aaf8e912a74b1daf36e392c4d8afdc19cf1e6af22cc94702ef4146fd
 SHA512:
-  metadata.gz: 3cbb55f4fab850bc9fb7b4cf55bb318bf846d54c3f78a399c50b76d325ddbcd12ad52072d224d75a25b6e5830c8fffa6d7e6f51ad522aae231bb2b374ac3980e
-  data.tar.gz: 4adfa615512c8f6652b85d5948c0a58c9851d30711fc2a1a7f870060601bb6fe0fab9af4ade0c8eebfb5e93a67bf60d1d6516e12fcd0ba96595d530049e0d0da
+  metadata.gz: b0f3278ba088effaba68eb1942872bb38dc7b73301bc7f0c5229ab773a69174da531d76009a2725912ab2615c67f1b6321ac3e20648e919adfd471e8a41eb309
+  data.tar.gz: 550862ccc0030a536896d219c2645c7194ec56357eebe9ae3eb08024811b60aca7fd857fd2e86daa80a406fa54e0050b922f80926ea66a14fcbb6fa71bcfda5b

data/CHANGELOG.md

@@ -5,6 +5,60 @@ 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).
 
+## [9.0.0] - 2026-10-09
+
+### Changed
+
+- **The split: space-architect is now the Architect Loop only.** The monolith
+  carved the space tool and the evergreen engine into their own gems —
+  **space-cadet** 9.0.0 (`Space::Core`, the `space` binary) and **repo-tender**
+  1.0.0 (`RepoTender`, the `repo-tender` binary with the deprecated `src`
+  shim) — and this gem consumes them as libraries instead of vendoring them.
+  Dropped: the vendored `lib/space_core` / `lib/space_src` subtrees, the
+  `exe/space` and `exe/src` binaries, and the `architect space …` / `architect
+  src …` forwarder intercepts. `architect space …` / `architect src …` are now
+  ordinary unknown commands (dry-cli usage + non-zero exit) — the `space`
+  binary comes from space-cadet and the `src` binary from repo-tender; re-point
+  8.x scripts and aliases accordingly.
+- **Upgrading from 8.x:** `gem uninstall space-architect` first — the 8.x gem's
+  `space` and `src` executables collide with the ones the new gems ship — then
+  `gem install space-architect` (pulls space-cadet) and, for the session-sync
+  rail, `gem install repo-tender`. Config/state: space-cadet ≥ 9.1 migrates the
+  substrate's `config.yml`/`state.yml` from the old
+  `~/.config|state/space-architect/` dirs automatically on first run of either
+  `space` or `architect` (on 9.0.0, move them across by hand); the loop's own
+  session-sync cursor stays where it is.
+- **Host-branded help header.** `architect --help`'s root header now brands
+  the loop (`architect 9.0.0 — …`) via space-cadet's product-name/version seam
+  instead of the substrate's identity — hence the `space-cadet ~> 9.1`
+  dependency floor.
+- **Own version line.** The loop's version is now
+  `Space::Architect::VERSION = "9.0.0"` (`lib/space_architect/version.rb`) —
+  its first, decoupled from `Space::Core::VERSION`. The gemspec version,
+  `architect --version`, the bug-report diagnostics, and the bug-report command
+  footer all derive from the loop's own constant; the bug report additionally
+  lists `space-cadet: <version>` as a dependency diagnostic.
+- **Dependency posture.** Hard dependency: `space-cadet ~> 9.0`. The declared
+  set shrank to what the loop itself requires (`async-http`, `async-process`,
+  `protocol-http`, `pastel`, `dry-cli`, `dry-monads`, `dry-validation` — `xdg`,
+  `tty-cursor`, `dry-struct`/`dry-types`, and bare `async` were the vendored
+  trees' deps, not the loop's). repo-tender is deliberately **not** a gemspec
+  runtime dependency: the `sessions agent` launchd seam requires it lazily and,
+  when the gem is absent, fails with a short actionable error naming the fix
+  (`gem install repo-tender`) instead of a LoadError backtrace. The dev
+  Gemfile includes repo-tender so the suite exercises the real integration.
+- **Tests and mutation subjects classified, not carried.** Tests whose subject
+  was the vendored tools' functionality (everything under `test/space_core/`
+  and `test/space_src/`, the forwarder tests, the space-tool surface,
+  shell-integration, slugger, repo-resolver, warnings) dropped with the code —
+  their coverage lives in the two gems. Loop tests keep running against the
+  gem-served `Space::Core`; fixture setup routes through the gem's own CLI.
+  The `:mutant` task now subjects `Space::Architect::GateEvaluator` and
+  `Space::Architect::GateLint` only.
+- **Docs and skills updated to the split reality** (README, command reference,
+  releasing guide, design doc, skills): one binary, two gem dependencies, no
+  forwarders or vendored subtrees.
+
 ## [8.0.0] - 2026-10-09
 
 ### Changed

data/README.md

@@ -2,24 +2,28 @@
 
 [![Gem Version](https://badge.fury.io/rb/space-architect.svg)](https://badge.fury.io/rb/space-architect)
 
-> **Task-scoped workspaces that double as Architect Loop projects — for humans and their agents!** ✨🛰️
+> **The Architect Loop — structured judgment-and-build cycles for humans and their agents!** ✨🛰️
 
-`space-architect` is a Ruby toolkit for **spaces** — task-scoped project
-workspaces that hold repos, notes, and artifacts under one obvious filesystem
-root — fused with the **Architect Loop**: a structured judgment-and-build cycle
-for you and a fleet of headless AI builders. 🌌
+`space-architect` is the gem behind the **Architect Loop**: a structured
+judgment-and-build cycle for you and a fleet of headless AI builders, run
+inside task-scoped **spaces** — directories that hold repos, notes, and
+artifacts under one obvious filesystem root. 🌌
 
-The gem ships **three composable binaries** over clean library seams:
+It installs **one executable**, `architect`. The spaces substrate and the
+evergreen-checkout engine live in two sibling gems:
 
-| Binary | What it does | Library |
-|--------|--------------|---------|
-| **`space`** 🪐 | Create, manage & containerize task-scoped workspaces | `Space::Core` |
-| **`architect`** 🏗️ | Run the Architect Loop — judgment + headless builders | `Space::Architect` |
-| **`src`** 🌲 | Tend evergreen repo checkouts for copy-on-write provisioning | `Space::Src` |
+| Gem | Dependency | What it provides |
+|-----|------------|------------------|
+| **space-cadet** | hard | The spaces substrate (`Space::Core`): create, manage & containerize task-scoped workspaces — the `space` binary — plus the copy-on-write evergreen-checkout substrate (`Cloner`, `SCM`) repos provision from |
+| **repo-tender** | soft | Evergreen clone tending — the `repo-tender` binary (with the deprecated `src` shim) — and the launchd agent the `architect sessions agent` commands drive. Install with `gem install repo-tender` when you want the session-sync rail — everything else works without it |
 
-Each is a first-class executable. `architect` also forwards `architect space …`
-and `architect src …` to the other two, so a project can drive everything from
-one command when that's handier. 🎀
+Until 8.x this gem was the monolith: it shipped `space`, `architect`, and `src`
+binaries (and `architect space …` / `architect src …` forwarders) plus the
+vendored `Space::Core` / `Space::Src` subtrees. The 9.0.0 split carved the
+tools into their own gems; this gem is the loop only. If you're on 8.x, get
+`space` from the **space-cadet** gem and `src` from **repo-tender** now — and
+`gem uninstall space-architect` first: the 8.x gem's `space`/`src` executables
+collide with the ones the new gems ship.
 
 ## What's a space? 🪐
 
@@ -37,10 +41,17 @@ everything a task needs:
   tmp/              # workspace-local temp — use this instead of /tmp
 ```
 
-Run a command from anywhere inside a space and it just works — `space` and
-`architect` walk up from `$PWD` until they find the nearest `space.yaml`. No
-"current space" state to get out of sync; where you *are* is the space you
-mean. 🧭
+Run an `architect` command from inside a space and it just works — the loop
+walks up from `$PWD` until it finds the nearest `space.yaml`. No "current
+space" state to get out of sync; where you *are* is the space you mean. 🧭
+
+Create and manage spaces with the **space-cadet** gem:
+
+```sh
+space init                                        # create XDG config + state files
+space new "Name of Space" -r org/repo -r org/lib  # blast off a new space 🚀
+space list                                        # see all your spaces
+```
 
 ## Installation 📦
 
@@ -58,25 +69,18 @@ Or grab it yourself:
 
 ```bash
 gem install space-architect
+gem install repo-tender   # optional: enables the sessions launchd agent
 ```
 
-The gem is `space-architect`; it installs three executables — `space`,
-`architect`, and `src`. 🎀
+The gem installs one executable: `architect`. 🎀
 
 ## Quick start 🎀
 
 ```sh
-# Spaces
+# Spaces (space-cadet gem)
 space init                                        # create XDG config + state files
-space new "Name of Space"                         # blast off a new space 🚀
-space new "Name of Space" -r org/repo -r org/lib  # …with repos cloned in (repeat -r)
-space list                                        # see all your spaces
-space show                                        # show the space you're standing in
-
-# Evergreen checkouts (copy-on-write sources for fast provisioning)
-src repo add github.com/example-org/example-app     # tend it 🌲
-src sync                                            # one sync pass
-src status                                          # per-repo evergreen status
+space new "Name of Space" -r org/repo -r org/lib  # blast off a new space 🚀
+space use 20260531-name-of-space                  # cd into a space by id
 
 # Architect Loop (run from inside a space)
 architect install-skills                          # install agent skills (once per machine)
@@ -84,157 +88,8 @@ architect init                                    # scaffold ARCHITECT.md + arch
 architect new my-feature                          # scaffold the next iteration file
 architect freeze my-feature                       # lock the Acceptance Criteria ❄️
 architect dispatch my-feature lane-a              # send a headless builder to work
-
-# Containers (run from inside a space) — a portable, reproducible-by-SHA image of the space
-space pack                                         # render build/oci/ (Dockerfile + entrypoint)
-space build                                        # pack + build & tag <space-id>:<git-sha>
-space run                                          # run it — login shell, auth from your env
 ```
 
-## `space` — task-scoped workspaces 🌌
-
-```sh
-space init
-space new "Name of Space"
-space new "Name of Space" -r org/repo -r example-tools/alpha -r example-tools/beta
-space list                                   # alias: space ls
-space show 20260531-name-of-space
-space path 20260531-name-of-space
-space current                                # based on $PWD
-space show                                   # based on $PWD
-space status                                 # report: metadata + loop status (based on $PWD)
-space status 20260531-name-of-space          # report another space
-space status done                            # set: active | paused | done | archived
-space status 20260531-name-of-space done
-space config set default_provider github.com
-space config set default_organization example-org
-space repo add example-app                   # github.com/example-org/example-app
-space repo add example-tools/alpha example-tools/beta
-space repo add gitlab.com/example-org/api
-space repo resolve example-app example-tools/async
-space repo ls                                # alias: space repos ls
-space use 20260531-name-of-space             # records recent state, prints the path
-space ls --color=always                      # auto | always | never (--colors also accepted)
-```
-
-`space status` is **report-or-set**: with no status keyword (bare, or with just
-a space id) it *reports* the space — its metadata plus a compact loop-status
-block (project status, current iteration, derived state) when the space runs an
-Architect project, quietly omitted otherwise; pass a status keyword (`active`,
-`paused`, `done`, `archived`) to *set* it instead. 🔁
-
-Repos are passed with a repeatable `-r` flag (`-r org/repo -r org/lib`); the
-comma form (`-r a,b`) works too. Space ids are date-prefixed
-(`20260531-name-of-space`) so they sort naturally, and duplicate names on the
-same day get a counter (`…-name-of-space-2`). 📅
-
-Everything `space` does is also reachable as `architect space …` from within a
-project.
-
-## Containerize a space: `pack` · `build` · `run` 📦
-
-A space is self-describing enough to become a container. `space pack` renders a
-portable OCI build context from the space; `space build` packs and builds it into
-a **reproducible-by-SHA** image; `space run` runs that image with your auth
-injected at runtime and stateful paths bind-mounted back to the host. 🐳
-
-```sh
-space pack                    # render build/oci/ (Dockerfile + entrypoint + ignore file)
-space pack -o /tmp/ctx        # …to a different output directory
-space build                   # pack, then build & tag <space-id>:<git-sha> and :latest
-space run                     # run <space-id>:latest — login shell, auth from your env
-space run architect status    # …or run a one-off command instead of the login shell
-space run --tty               # force an interactive TTY (default: auto-detect)
-```
-
-**What lands in the image.** The context copies the whole space tree (filtered by
-a generated `Dockerfile.dockerignore`) onto a `ruby:4.0.5` base with `git`, the
-Claude Code CLI, and the `space-architect` gem — installed from the in-space
-`repos/space-architect` checkout when present (a pinned build), else from
-RubyGems. Secrets never enter the layers: `.env`, `*.key`, `*.pem`, ssh keys,
-`build/`, and `tmp/` are all excluded by the generated ignore file. 🔒
-
-**Reproducible by SHA.** `space build` tags the image `<space-id>:<sha>`, where
-`<sha>` is the space repo's 12-char `HEAD` (suffixed `-dirty` when the tree has
-uncommitted changes), plus a moving `:latest`. Same commit → same tag → same
-image. It drives the `container` CLI, but the output is an ordinary OCI/Docker
-build context, so `docker build -f build/oci/Dockerfile .` (from the space root)
-works just as well.
-
-**Auth stays out of the layers.** `space run` injects only the auth environment
-variables that are actually set — `ANTHROPIC_API_KEY`, `CLAUDE_CODE_OAUTH_TOKEN`,
-`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
-pack:
-  provision:                 # build-time: relative scripts, baked in by `space build`
-    - scripts/setup-toolchain.sh
-  persist:                   # run-time: absolute guest paths, bind-mounted per run
-    - /root/.claude
-    - /root/.local/state
-```
-
-`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.
-
-## `src` — the evergreen engine 🌲
-
-`src` keeps local clones under `<src_dir>/<host>/<owner>/<repo>` (default
-`~/architect/src/…`) clean, on their default branch, and freshly fetched — so
-spaces can provision repos by **copy-on-write** instead of cloning over the
-network.
-
-```sh
-src repo add github.com/example-org/example-app     # track + tend a repo
-src org add github.com/example-org                  # track a whole org
-src sync                                            # run one sync pass (--repo to scope)
-src status                                          # per-repo evergreen status table
-src clone example-app                               # APFS copy-on-write into $PWD
-src daemon install                                  # per-user launchd agent for background sync
-```
-
-When `space repo add` finds a matching evergreen checkout, it copy-on-writes
-from it instead of hitting the network — instant provisioning. ⚡ The two
-surfaces share one layout by design, so they line up with zero configuration:
-
-```sh
-src repo add github.com/example-org/example-app   # tend it: keep it evergreen 🌲
-space repo add example-app                          # copies it instantly ⚡
-```
-
-`src` has its own `--plain` / `--json` output modes for scripting, and its own
-fish integration (`src shell fish install`).
-
 ## `architect` — the Architect Loop 🏗️
 
 The **Architect Loop** is a structured build cycle for you and headless AI
@@ -396,80 +251,35 @@ architect install-skills --dry-run               # show what would change
 `architect-vocabulary` loads the system's terms and a short orientation when
 you're in a space but don't want to run the loop.
 
-## Fish shell integration 🐟
-
-Shells can't let a child process change *their* working directory, so `space`
-and `src` each ship a small fish wrapper function plus completions (commands,
-subcommands, spaces, statuses, config keys, repo refs). Install into fish's
-autoloaded directories:
+### Sessions: the launchd rail 🛰️ (requires repo-tender)
 
-```fish
-space shell fish install
-src shell fish install
-exec fish
-```
-
-After restarting fish (or `exec fish`), `space new "…"` and
-`space use <id>` will `cd` into the selected space once the command succeeds;
-every other command keeps normal CLI behavior. 🚪 The functions and completions
-are written under `~/.config/fish/`, so there's no need to edit `config.fish`.
-For one-off testing without installing:
-
-```fish
-space shell init fish | source
-```
+`architect sessions sync` uploads new conversation transcripts (`~/.pi/agent/sessions`
+and `~/.claude/projects`) to a space-server; `architect sessions agent
+install|uninstall|status` manages the per-user launchd agent that runs the sync
+on an interval. These commands drive **repo-tender**'s launchd agent — a *soft*
+dependency, deliberately absent from the gemspec: without the gem, the sessions
+agent commands print a short error naming the fix (`gem install repo-tender`)
+and the rest of `architect` is unaffected.
 
 ## Configuration ⚙️
 
-Config lives at `~/.config/space-architect/config.yml` (XDG-aware) and defaults to:
-
-```yaml
-version: 1
-base_dir: ~/architect            # spaces_dir + src_dir hang off this by default
-default_provider: github.com
-default_organization:
-git_clone_protocol: ssh          # ssh | https
-```
-
-Derived defaults: `spaces_dir` → `<base_dir>/spaces`, `src_dir` (evergreen
-checkout root) → `<base_dir>/src`. Override either explicitly. View values with
-`space config show`; set one with `space config set KEY VALUE`. Editable keys:
-`base_dir`, `spaces_dir`, `src_dir`, `default_provider`, `default_organization`,
-`git_clone_protocol`.
-
-## Repos: evergreen, copy-on-write, concurrent ⚡
-
-Repos are added to the current space under `repos/` and tracked in `space.yaml`.
-When an up-to-date evergreen checkout exists at
-`<src_dir>/<host>/<owner>/<name>` (e.g.
-`~/architect/src/github.com/example-org/example-app`), `space` copies it into the
-space instead of cloning over the network — a copy-on-write clone on APFS. ⚡
-Set `src_dir` empty to always clone:
-
-```sh
-space config set src_dir ""
-```
-
-Clone URLs default to SSH (`git@github.com:example-org/example-app.git`); switch
-with `space config set git_clone_protocol https`. Multiple repos passed to
-`space repo add` are fetched **concurrently**, up to five at a time, on fibers —
-no threads, all cooperative. 🧵 After each repo lands, `space` runs `mise trust`
-in it. Each space also gets a workspace-local `tmp/` — use it instead of `/tmp`.
+The spaces config the loop reads lives at `~/.config/space-cadet/config.yml`
+(XDG-aware, owned by the space-cadet gem) — see `space config show`. The loop
+itself has no config of its own: a space's `space.yaml` `project:` block *is*
+the loop's state.
 
 ## Embedding 📚
 
-The library is split into three namespaces you can require independently:
+Two namespaces, published as two gems:
 
-- **`Space::Core`** — the foundation: config, state, XDG, terminal, git/mise
-  clients, the space store. The `space` CLI runs on this alone.
-- **`Space::Architect`** — project state, the builder harness, dispatch, and the
-  research supervisor.
-- **`Space::Src`** — the evergreen engine (tracking, sync, copy-on-write clone).
+- **`Space::Core`** (the space-cadet gem) — the substrate: config, state, XDG,
+  terminal, git/mise clients, the space store. The `space` CLI runs on this.
+- **`Space::Architect`** (this gem) — project state, the builder harness,
+  dispatch, and the research supervisor, over the `Space::Core` substrate.
 
 ```ruby
-require "space_core"       # just spaces
-require "space_architect"  # the full loop (pulls in core + src)
-require "space_src"        # just the evergreen engine
+require "space_core"       # just spaces (space-cadet gem)
+require "space_architect"  # the loop (pulls in the space-cadet gem)
 ```
 
 ## Documentation 📖

data/lib/space_architect/bug_report.rb

@@ -79,7 +79,8 @@ module Space
           <<~MD
             ## Diagnostics
 
-            - space-architect: #{Space::Core::VERSION}
+            - space-architect: #{Space::Architect::VERSION}
+            - space-cadet: #{Space::Core::VERSION}
             - ruby: #{RUBY_VERSION} (#{RUBY_PLATFORM})
           MD
         end

data/lib/space_architect/cli/architect.rb

@@ -2,7 +2,6 @@
 
 require "json"
 require "fileutils"
-require "space_src/launchd/agent"
 require_relative "../jobs_client"
 require_relative "../conversations_client"
 require_relative "../session_sync"
@@ -12,8 +11,8 @@ module Space::Architect
     # 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).
+    # <order>. Only architect commands declare one — commands without a phase
+    # render as the single ungrouped default listing (unchanged).
     class BaseCommand
       def self.phase(order = nil, label = nil)
         return @phase if order.nil?
@@ -800,7 +799,8 @@ module Space::Architect
             terminal.say result[:command]
             terminal.say ""
             terminal.say "Diagnostics:"
-            terminal.say "  space-architect #{Space::Core::VERSION}"
+            terminal.say "  space-architect #{Space::Architect::VERSION}"
+            terminal.say "  space-cadet #{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))
@@ -1168,6 +1168,17 @@ module Space::Architect
             end
 
             def format_failure(f) = f.is_a?(Hash) ? f.inspect : f.to_s
+
+            # The launchd-agent seam is repo-tender's — a soft dependency, never a
+            # gemspec runtime dep. Required lazily so `sessions agent …` degrades
+            # with an actionable hint instead of failing at boot when the gem is
+            # absent; handle_errors turns the raise into a red message + exit 1.
+            def agent
+              require "repo_tender"
+              RepoTender::Launchd::Agent
+            rescue LoadError
+              raise Space::Core::Error, "sessions agent needs the repo-tender gem — install it with: gem install repo-tender"
+            end
           end
 
           class Install < BaseCommand
@@ -1196,7 +1207,7 @@ module Space::Architect
                 File.write(pp, xml)
                 File.chmod(0o600, pp)
 
-                result = Space::Src::Launchd::Agent.new(label: SessionSync::LABEL).install(pp)
+                result = agent.new(label: SessionSync::LABEL).install(pp)
                 raise Space::Core::Error, "bootstrap failed: #{format_failure(result.failure)}" if result.failure?
 
                 terminal.say "Installed: #{terminal.path(pp)}"
@@ -1213,7 +1224,7 @@ module Space::Architect
               setup_terminal(**opts.slice(:color, :colors))
               handle_errors do
                 pp = plist_path
-                result = Space::Src::Launchd::Agent.new(label: SessionSync::LABEL).uninstall
+                result = agent.new(label: SessionSync::LABEL).uninstall
                 terminal.say "bootout reported: #{format_failure(result.failure)}" if result.failure?
 
                 if File.exist?(pp)
@@ -1234,7 +1245,7 @@ module Space::Architect
             def call(**opts)
               setup_terminal(**opts.slice(:color, :colors))
               handle_errors do
-                result = Space::Src::Launchd::Agent.new(label: SessionSync::LABEL).status
+                result = agent.new(label: SessionSync::LABEL).status
                 raise Space::Core::Error, "status failed: #{format_failure(result.failure)}" if result.failure?
 
                 s = result.success
@@ -1256,6 +1267,8 @@ 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::Core::CLI::Help.product_name = "architect"
+Space::Core::CLI::Help.product_version = Space::Architect::VERSION
 
 Space::Architect::CLI::Registry.register "init",   Space::Architect::CLI::Architect::Init
 Space::Architect::CLI::Registry.register "ground", Space::Architect::CLI::Architect::Ground

data/lib/space_architect/cli.rb

@@ -33,21 +33,11 @@ module Space::Architect
       end
 
       if VERSION_REQUEST.include?(argv)
-        out.puts Space::Core::VERSION
+        out.puts Space::Architect::VERSION
         return 0
       end
 
-      if argv.first == "src"
-        return dispatch_src(argv[1..], out, err)
-      end
-
-      normalized = normalize_args(argv)
-
-      if normalized.first == "space"
-        return dispatch_space(normalized[1..], out, err)
-      end
-
-      Dry::CLI.new(Registry).call(arguments: normalized, out: out, err: err)
+      Dry::CLI.new(Registry).call(arguments: normalize_args(argv), out: out, err: err)
       last_outcome&.exit_code || 0
     end
 
@@ -88,6 +78,13 @@ module Space::Architect
     end
 
     def self.run(argv, out = $stdout, err = $stderr)
+      # One-shot 8.x app-dir migration (the substrate's config/state, owned by
+      # Space::Core::Migration in space-cadet) before dispatch — skipped for
+      # the pure help/version queries so they stay side-effect-free. Running it
+      # here too means `architect` picks up an 8.x user's config even if they
+      # never ran `space` first.
+      Space::Core::Migration.run(err: err) unless TOP_LEVEL_HELP.include?(argv) || VERSION_REQUEST.include?(argv)
+
       Kernel.exit(call(argv, out, err))
     rescue Interrupt
       err.puts "interrupted"
@@ -97,6 +94,4 @@ module Space::Architect
 end
 
 require_relative "cli/architect"
-require_relative "cli/space"
-require_relative "cli/src"
 require_relative "cli/research"

data/lib/space_architect/session_sync/bin_path.rb

@@ -5,7 +5,7 @@ require "open3"
 module Space::Architect
   module SessionSync
     # Resolves the absolute path to the `architect` executable the plist
-    # should invoke, imitating Space::Src::CLI::Daemon::Helpers::Resolve's
+    # should invoke, imitating RepoTender::CLI::Daemon::Helpers::Resolve's
     # detect_bin_path precedence: an env override (tests), the dev checkout's
     # exe/architect, `which architect`, then the installed gem's bin.
     module BinPath

data/lib/space_architect/session_sync/cursor.rb

@@ -6,7 +6,7 @@ require "fileutils"
 module Space::Architect
   module SessionSync
     # Machine-managed cursor at $XDG_STATE_HOME/space-architect/session-sync.yaml
-    # (imitates Space::Src::State::Store's load/write/emit shape). Keyed by
+    # (imitates RepoTender::State::Store's load/write/emit shape). Keyed by
     # absolute source path; each entry records the size + mtime observed the
     # last time that file was uploaded.
     class Cursor

data/lib/space_architect/session_sync/plist.rb

@@ -3,7 +3,7 @@
 module Space::Architect
   module SessionSync
     # Hand-rolled launchd plist emitter for the session-sync agent, imitating
-    # Space::Src::Launchd::Plist's shape. Under launchd's bare PATH, a bare
+    # RepoTender::Launchd::Plist's shape. Under launchd's bare PATH, a bare
     # env-relative ruby binstub shebang resolves to macOS system Ruby instead
     # of the caller's toolchain, so ProgramArguments names the interpreter
     # explicitly (ruby_bin) rather than relying on shebang resolution — no

data/lib/{space_core → space_architect}/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Space
-  module Core
-    VERSION = "8.0.0"
+  module Architect
+    VERSION = "9.0.0"
   end
 end

data/lib/space_architect.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "space_core"
-require "space_src"
+require_relative "space_architect/version"
 
 require_relative "space_architect/harness"
 require_relative "space_architect/run_creator"

data/skill/architect/SKILL.md

@@ -151,8 +151,9 @@ loop.
   an iteration index pointing at each iteration file; per-iteration detail lives
   in the iteration file, never duplicated into the handoff. `architect status`
   prints project state (iterations, freeze_shas, lanes, verdicts) at any point.
-- **Space setup (first time):** `architect space new "Project Name" -r org/repo -r …`
-  (each repo is a repeatable `-r` flag after the title), then `architect init` inside
+- **Space setup (first time):** `space new "Project Name" -r org/repo -r …`
+  (the space-cadet binary; each repo is a repeatable `-r` flag after the title),
+  then `architect init` inside
   the space to scaffold `architecture/ARCHITECT.md`.
 - Scale to the task: trivial fixes don't need the loop — say so and let the
   human do it inline or in a normal session. The loop is for iteration-sized

data/skill/architect-vocabulary/SKILL.md

@@ -131,8 +131,8 @@ Safe **read-only** commands to orient yourself (these don't run the loop):
 
 ```sh
 architect status            # project state: iterations, freeze shas, lanes, verdicts
-architect space show        # the space you're standing in
-architect space list        # all your spaces
+space show                  # the space you're standing in (space-cadet binary)
+space list                  # all your spaces
 ```
 
 ## Maintenance