space-architect 9.2.1 → 9.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 173cd44e1e27f8fc09d46bb0d18a5c7f26138731d4315bc6db1e7cd2c704e0a4
-  data.tar.gz: cebbf1f5602efa92a9f3982f31fcc79c202549489531262cfaab3ecc1c25ba13
+  metadata.gz: e768903f0762630e4c4c510a83621cf4c82be30ea7d95026d794f90d70205f44
+  data.tar.gz: 77c7b1faae07696200558929456ab481aa5f8f061f69a0ff923fac53a4957f2c
 SHA512:
-  metadata.gz: 44430c9d2fb759035df014e4023084424b66edd6dfea696f4e0e0f555ab7d0e3d418410ae8fa117936456fd3b4ea365cf9bf217ffadbb0be184e9ccb6835526a
-  data.tar.gz: 5abb3a70daaca512e957ed2a577a45904e709be3cd05c6b57ae49f7e58ce9d612b64c33addb6ba191f49777826258e5b481e27c440bacdfd4f4e8d7f4d997dd0
+  metadata.gz: 27e9c5abd1ae5a60b42aee5bed88640b3dd49352214b2af420384333b8d93c558369e14220f4f996729d1ccdcf4155552e05dbd59c0ffaf05ca81fe0ea4f9489
+  data.tar.gz: 5e86aa794e2ec154f8e797040cdadd6a59c43489bf98ffdb070f8e7d90a82572e73f19ba5cadedfebdd90fea29062fd0fa873e9bba08cf06f1277483a60e7ee0

data/CHANGELOG.md

@@ -5,6 +5,95 @@ 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.4.0] - 2026-10-17
+
+### Added
+
+- **The skill family.** `/architect` is now the inline working mode — work
+  outside the loop at a conversational cadence (UI, ops, small fixes), with
+  the space as the workspace (notes kept, `ARCHITECT.md` updated, commits
+  when the work calls for them) and the vocabulary glossary folded in.
+  **`/architect-discuss`** carries the judgment seat: exploration,
+  arbitration, judging finished runs, landing, iteration surgery.
+  **`/architect-status`** reports state read-only from CLI output and the
+  newest notes. The coordinator launch is agent-owned end to end:
+  **`/architect-action`** (renamed from `/architect-plan`) launches via the
+  new `architect_loop` pi-extension tool (jetpks/pi-extensions) — the
+  agent-side equivalent of `/loop`, sharing one spawn path so the two cannot
+  drift, awaiting the run id, then self-compacting the launching session
+  into a small on-call escalation seat.
+
+### Changed
+
+- The `install-skills` help text, `docs/DESIGN.md`, and
+  `docs/reference/project.md` describe the five-skill family; the
+  `/architect-discuss` routing section now describes the real dual
+  agent-file mechanism (per-space `.pi/agents/` generation with resolved
+  pins, plus user-level `install-agents` playbooks as the headless/
+  untrusted fallback) instead of claiming nothing generates into the space.
+
+### Removed
+
+- **`/architect-plan`** (renamed to `/architect-action`) and
+  **`/architect-vocabulary`** (folded into `/architect`); the `dispatch.md`
+  and `research.md` companion references moved to the discuss skill.
+
+## [9.3.0] - 2026-10-17
+
+### Removed
+
+- **The gem cut (observation-deck entry 2).** Session capture moved to the
+  session-sink pi extension (jetpks/pi-extensions), so the gem's entire
+  push/streaming surface is gone: `SpacePush`/`Packer` and the `architect
+  push` command; dispatch `--push-url/--push-host/--push-token`, `RunCreator`,
+  and the harness tee; `ConversationsClient` + `session_sync/**` and the
+  sessions CLI that drove them; `JobsClient` (its only consumer was the
+  removed server jobs API). looplog, runlog, cost, routing, and the loop
+  lifecycle are untouched.
+
+## [9.2.1] - 2026-10-15
+
+### Fixed
+
+- dispatch copies the lane prompt into the build dir (`build/<id>-<lane>/`
+  `prompt.md`) at dispatch time, so the record is self-contained even if the
+  scratch source is removed.
+
+## [9.2.0] - 2026-10-15
+
+### Added
+
+- **CLI observability:** `architect looplog` (follow every active loop run
+  live; `--list`/`--replay`/`--all`), `architect runlog` (pretty-print or
+  stream a run.jsonl), and full gate transcripts written to
+  `build/gate/<id>-<ts>.md`.
+
+### Changed
+
+- Docs re-centered on the coordinator path; role agents installed user-level
+  by `architect install-agents`.
+
+## [9.1.1] - 2026-10-14
+
+### Fixed
+
+- `architect provision` fast-forward-syncs the integration branch from the
+  default branch (or cuts exactly `--base REF`), refusing loudly on
+  divergence instead of silently building on a stale base.
+
+## [9.1.0] - 2026-10-13
+
+### Added
+
+- **The narrator role:** a sixth loop role (cheap model, one file per settled
+  event) writing `notes/narrative-*.md` — verbatim facts, never a gate.
+
+### Changed
+
+- `architect cost` gains human formatting (significant figures, `--precise`,
+  color) and a latency turn/generation split.
+- `architect new` flocks the scaffold critical section across processes.
+
 ## [9.0.0] - 2026-10-09
 
 ### Changed

data/README.md

@@ -12,19 +12,17 @@ task-scoped **spaces**: directories that hold repos, notes, and artifacts under
 one obvious filesystem root. Nothing lives only in a chat window — every
 decision, spec, and verdict is committed to the space repo.
 
-It installs **one executable**, `architect`. The spaces substrate and the
-evergreen-checkout engine are two sibling gems:
+It installs **one executable**, `architect`. The spaces substrate is a sibling
+gem:
 
 | 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 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 |
 
 ## Installation 📦
 
 ```bash
 gem install space-architect
-gem install repo-tender   # optional: enables the sessions launchd agent
 ```
 
 The gem installs one executable: `architect`. 🎀 (Or add

data/lib/space_architect/architect_project.rb

@@ -956,13 +956,7 @@ module Space::Architect
 
     def dispatch(iteration, lane, model: nil, max_turns: 200, bin: nil, harness: nil, effort: nil,
                  force: false, quiet: false,
-                 detach: false, push_url: nil, push_token: nil, push_host: nil, run_creator: nil,
-                 push_client: nil, timeout: nil, prompt: nil, now: Time.now)
-      raise Space::Core::Error, "Specify --push-host or --push-url, not both" if push_host && push_url
-      raise Space::Core::Error, "--push-host requires --push-token"           if push_host && !push_token
-      raise Space::Core::Error, "--detach cannot be combined with --push-url or --push-host" \
-        if detach && (push_url || push_host)
-
+                 detach: false, timeout: nil, prompt: nil, now: Time.now)
       err = quiet ? File.open(File::NULL, "w") : $stderr
 
       entry = slice_entry(iteration)
@@ -1026,26 +1020,14 @@ module Space::Architect
         result[:prompt_copied] = prompt_path if prompt
         result
       else
-        created_run_id = nil
-        if push_host
-          creator        = run_creator || RunCreator.new(push_host, push_token)
-          created_run_id = creator.create
-          push_url       = "#{push_host.chomp('/')}/runs/#{created_run_id}/ingest"
-        end
-
         run_kwargs = { prompt_path: prompt_path, run_log_path: run_log_path, chdir: wt_path }
         run_kwargs[:timeout] = timeout if timeout
-        run_kwargs[:push_url]    = push_url    if push_url
-        run_kwargs[:push_token]  = push_token  if push_token
-        run_kwargs[:push_client] = push_client if push_client
-        run_kwargs[:err]         = err         if quiet
+        run_kwargs[:err] = err if quiet
         exit_code = harness_obj.run(**run_kwargs)
 
         result = { exit_code: exit_code, run_log: run_log_path, report: report_path, worktree: wt_path }
         result[:prompt_copied]  = prompt_path    if prompt
         result[:timed_out]      = true           if exit_code == Harness::PiHarness::TIMEOUT_EXIT_CODE
-        result[:created_run_id] = created_run_id if created_run_id
-        result[:push_url]       = push_url       if push_url
         result
       end
     end
@@ -1731,7 +1713,7 @@ module Space::Architect
     # two paths looked at, and the default in use.
     def default_model_inform
       "model: no architect.yaml found (looked at #{Routing.space_path(space.path)} + #{Routing.global_path}) — " \
-        "using default '#{Harness::DEFAULT_MODEL}'"
+        "using default '#{Harness::DEFAULT_MODEL}' #{Routing::INIT_HINT}"
     end
 
     # --prompt: the caller authors the lane prompt anywhere (a fresh scratch file) and

data/lib/space_architect/cli/architect.rb

@@ -2,14 +2,10 @@
 
 require "json"
 require "fileutils"
-require_relative "../jobs_client"
-require_relative "../conversations_client"
 require_relative "../loop_cost"
-require_relative "../session_sync"
 require_relative "../runlog"
 require_relative "../looplog"
 require_relative "../extension_installer"
-require_relative "../space_push"
 
 module Space::Architect
   module CLI
@@ -173,7 +169,9 @@ module Space::Architect
               # Legacy lanes store no model — resolve the config layer once so the
               # display shows what they would actually route, and mark the bare
               # constant as the last resort it is, not ordinary behavior.
-              config_model = Routing.for_space(sp.path)&.dig("builder", "model")
+              # Fully qualified: the Architect::Routing subcommand namespace
+              # (I09) lexically shadows Space::Architect::Routing inside this module.
+              config_model = Space::Architect::Routing.for_space(sp.path)&.dig("builder", "model")
 
               terminal.say "Project status:     #{block['status'] || '(none)'}"
               terminal.say "Current iteration:  #{block['current_iteration'] || '(none)'}"
@@ -215,41 +213,6 @@ module Space::Architect
         end
       end
 
-      class Push < BaseCommand
-        desc "Pack the current space and push it to a space-server for import"
-        phase 53, "Project"
-        argument :space, required: false, desc: "Space identifier (default: $PWD)"
-        option :host,  required: true, desc: "Base URL of the space-server"
-        option :token, required: true, desc: "Bearer token for authorization"
-
-        def call(space: nil, host: nil, token: nil, **opts)
-          setup_terminal(**opts.slice(:color, :colors))
-          handle_errors do
-            raise Space::Core::Error, "--host is required" unless host
-            raise Space::Core::Error, "--token is required" unless token
-
-            render(store.find(space)) do |sp|
-              bundle = SpacePush::Packer.new(sp.path).pack
-              begin
-                terminal.say "Packed #{sp.id}: #{format_bytes(File.size(bundle))}"
-                summary = SpacePush.new(host, token).push(bundle)
-                terminal.say "Imported: #{summary['slug']} (id #{summary['id']}) — " \
-                  "#{summary['iterations']} iterations, #{summary['artifacts']} artifacts, #{summary['runs']} runs"
-                CLI.record_outcome(Outcome.new(exit_code: 0))
-              ensure
-                File.delete(bundle)
-              end
-            end
-          end
-        end
-
-        private
-
-        def format_bytes(size)
-          format("%.1f MiB", size.to_f / (1024 * 1024))
-        end
-      end
-
       class Sync < BaseCommand
         desc "Sync tracked repo clones with their remotes (fast-forward only, no rebase/reset)"
         phase 53, "Project"
@@ -560,17 +523,14 @@ module Space::Architect
         option   :force_effort,    default: nil, desc: "Force the literal level onto the --thinking flag, skipping architect's validation — alias for --force-thinking/--force-reasoning (dispatch only; the binary's rejection is final)"
         option   :force_thinking,  default: nil, desc: "Force the literal level onto the --thinking flag, skipping architect's validation — alias for --force-effort/--force-reasoning (dispatch only; the binary's rejection is final)"
         option   :force_reasoning, default: nil, desc: "Force the literal level onto the --thinking flag, skipping architect's validation — alias for --force-effort/--force-thinking (dispatch only; the binary's rejection is final)"
-        option   :quiet,    type: :boolean, default: false, desc: "Suppress thinking-translation and harness run-time warn lines (liveness/push) on $stderr for this dispatch"
+        option   :quiet,    type: :boolean, default: false, desc: "Suppress thinking-translation and harness run-time warn lines (liveness) on $stderr for this dispatch"
         option   :detach,    type: :boolean, default: false, desc: "Detach the builder process (returns immediately with PID; poll report for completion)"
         option   :timeout,   default: "14400", desc: "Wall-clock timeout in seconds (0 disables; default 4h); foreground only"
-        option   :push_url,   default: nil,   desc: "HTTP endpoint for streaming push (POST body to this URL)"
-        option   :push_token, default: nil,   desc: "Bearer token for push endpoint authorization"
-        option   :push_host,  default: nil,   desc: "Base URL of the ingest server; the CLI creates a run via POST <host>/runs and streams to /runs/<id>/ingest (requires --push-token)"
 
         def call(iteration:, lane:, space: nil, prompt: nil, model: nil,
                  max_turns: "200", harness: nil, effort: nil, thinking: nil, reasoning: 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, **opts)
+                 timeout: "14400", **opts)
           setup_terminal(**opts.slice(:color, :colors))
           handle_errors do
             level = resolve_thinking_alias(effort: effort, thinking: thinking, reasoning: reasoning)
@@ -588,9 +548,6 @@ module Space::Architect
               kwargs[:force]      = true            if forced_level
               kwargs[:quiet]      = true             if quiet
               kwargs[:timeout]    = timeout.to_i    unless detach
-              kwargs[:push_url]   = push_url        if push_url
-              kwargs[:push_token] = push_token      if push_token
-              kwargs[:push_host]  = push_host       if push_host
               res = project.dispatch(iteration, lane, **kwargs)
               terminal.say "Prompt:  #{prompt} → #{terminal.path(res[:prompt_copied])}" if res[:prompt_copied]
               if detach
@@ -607,7 +564,6 @@ module Space::Architect
               else
                 terminal.say "Run log: #{terminal.path(res[:run_log])}"
                 terminal.say "Report:  #{terminal.path(res[:report])}"
-                terminal.say "Ingest URL:  #{res[:push_url]}" if res[:push_url]
                 terminal.say "Builder exited with status #{res[:exit_code]}"
                 unless res[:report].exist? && !res[:report].read.strip.empty?
                   terminal.say "WARNING: no report at #{terminal.path(res[:report])} — the lane produced no deliverable."
@@ -953,7 +909,7 @@ module Space::Architect
         # --help, which :boolean would render as `--[no-]json`.
         option :json,          type: :flag, default: false, desc: "Emit the frozen JSON contract instead of tables"
         option :space,         desc: "Space identifier or path (default: nearest ancestor with space.yaml)"
-        option :sessions_root, desc: "pi sessions root (default: ~/.pi/agent/sessions via SessionSync)"
+        option :sessions_root, desc: "pi sessions root (default: ~/.pi/agent/sessions)"
         option :since,         desc: "Only artifacts starting at/after this ISO-8601 timestamp or YYYY-MM-DD date"
         option :by_iteration,  type: :flag, default: false, desc: "Split the cost table into per-iteration windows"
         option :latency,       type: :flag, default: false, desc: "Per-model latency: round wall, turn vs generation tok/s, tool wait share"
@@ -969,7 +925,7 @@ module Space::Architect
             render(store.find(space)) do |sp|
               report = LoopCost.report(
                 space: sp,
-                sessions_root: sessions_root || SessionSync.default_pi_root,
+                sessions_root: sessions_root || default_pi_sessions_root,
                 since: since,
                 by_iteration: by_iteration,
                 latency: latency
@@ -982,6 +938,12 @@ module Space::Architect
 
         private
 
+        # The pi sessions root Cost reads by default — the same value the cut
+        # session-sync rail's default computed.
+        def default_pi_sessions_root(env: ENV)
+          File.join(Space::Core::XDG.home(env: env), ".pi", "agent", "sessions")
+        end
+
         def render_cost_text(report, by_iteration, latency, precise)
           if latency
             latency_table(report["latency"], precise)
@@ -1100,7 +1062,7 @@ module Space::Architect
       end
 
       class InstallSkills < BaseCommand
-        desc "Install bundled skills (architect, architect-research, architect-vocabulary) for a harness"
+        desc "Install bundled skills (architect, architect-discuss, architect-action, architect-status, architect-research) for a harness"
         phase 53, "Project"
         option :provider, default: "claude", desc: "Skill install target (default: claude; validated by the installer)"
         option :project, type: :boolean, default: false, desc: "Install to CWD instead of global"
@@ -1140,6 +1102,56 @@ module Space::Architect
         end
       end
 
+      module Routing
+        # I09: `architect routing init` — the self-service cure for the
+        # missing-config wall (default_model_inform's hint names this command).
+        # Writes Routing::TEMPLATE verbatim and round-trips the write through
+        # Routing.parse before claiming success; the routing machinery itself
+        # is untouched — the command only writes a file it already accepts.
+        class Init < BaseCommand
+          desc "Write a commented starter architect.yaml (space root by default; --global for the machine-wide config)"
+          phase 53, "Project"
+          argument :space, required: false, desc: "Space identifier (default: $PWD)"
+          option :global, type: :boolean, default: false,
+            desc: "Write ~/.config/space-architect/architect.yaml (the machine-wide config; SPACE_ARCHITECT_GLOBAL_CONFIG overrides the path) instead of the space root, creating parent directories as needed"
+
+          def call(space: nil, global: false, **opts)
+            setup_terminal(**opts.slice(:color, :colors))
+            handle_errors do
+              target =
+                if global
+                  raise Space::Core::Error, "--global and an explicit space argument are mutually exclusive" if space
+                  # Routing.global_path is the env-overridable canonical path — never re-derive it here.
+                  path = Space::Architect::Routing.global_path
+                  FileUtils.mkdir_p(path.dirname)
+                  path
+                else
+                  # The house walk-up: empty identifier looks for space.yaml from $PWD upward.
+                  found = store.find(space).value_or(nil)
+                  unless found
+                    raise Space::Core::Error,
+                      "no space.yaml found upward from #{Dir.pwd} — run `architect routing init --global` to scaffold the machine-wide config instead"
+                  end
+                  Space::Architect::Routing.space_path(found.path)
+                end
+
+              raise Space::Core::Error, "architect.yaml already exists: #{target} — routing init never overwrites" if target.exist?
+
+              File.write(target, Space::Architect::Routing::TEMPLATE)
+              # A scaffold that fails its own parser (or misses a required role)
+              # is a bug — validate the round-trip, let the error escape loud.
+              parsed = Space::Architect::Routing.parse(File.read(target), target)
+              missing = Space::Architect::Routing::REQUIRED_ROLES - parsed.keys
+              raise Space::Core::Error, "scaffolded #{target} is missing required roles: #{missing.join(', ')}" if missing.any?
+
+              terminal.say "Wrote starter routing config: #{terminal.path(target.to_s)}"
+              terminal.say "Edit the example/REPLACE_ME models; the next command or /loop picks the file up."
+              CLI.record_outcome(Outcome.new(exit_code: 0))
+            end
+          end
+        end
+      end
+
       module Worktree
         class Add < BaseCommand
           desc "Create a worktree for a lane"
@@ -1340,235 +1352,6 @@ module Space::Architect
           end
         end
       end
-
-      module Jobs
-        # dry-cli 1.4.1 only enforces `required: true` on argument, not on
-        # option (Dry::CLI::Parser#parse_required_params only ever consults
-        # command.required_arguments) — a missing --host/--token would
-        # otherwise surface as a raw ArgumentError from the **opts keyword
-        # splat, uncaught by handle_errors. Every subcommand below validates
-        # explicitly so the failure is a clean Space::Core::Error instead.
-        def self.require_credentials!(host, token)
-          raise Space::Core::Error, "--host is required" unless host
-          raise Space::Core::Error, "--token is required" unless token
-        end
-
-        class List < BaseCommand
-          desc "List jobs for the authenticated user (owner-scoped, newest-first)"
-          option :host,  required: true, desc: "Base URL of the space-server"
-          option :token, required: true, desc: "Bearer token for authorization"
-
-          def call(host: nil, token: nil, **opts)
-            setup_terminal(**opts.slice(:color, :colors))
-            handle_errors do
-              Jobs.require_credentials!(host, token)
-              jobs = JobsClient.new(host, token).list
-              if jobs.empty?
-                terminal.say "No jobs"
-              else
-                rows = jobs.map do |j|
-                  [j["id"], j["status"], j["run_id"], j["created_at"],
-                   j["harness"], j["model"], j.dig("provenance", "lane")]
-                end
-                terminal.say terminal.table(%w[ID Status RunID CreatedAt Harness Model Lane], rows)
-              end
-              CLI.record_outcome(Outcome.new(exit_code: 0))
-            end
-          end
-        end
-
-        class Show < BaseCommand
-          desc "Show a job's full JSON"
-          argument :id, required: true, desc: "Job id"
-          option   :host,  required: true, desc: "Base URL of the space-server"
-          option   :token, required: true, desc: "Bearer token for authorization"
-
-          def call(id:, host: nil, token: nil, **opts)
-            setup_terminal(**opts.slice(:color, :colors))
-            handle_errors do
-              Jobs.require_credentials!(host, token)
-              job = JobsClient.new(host, token).show(id)
-              terminal.say JSON.pretty_generate(job)
-              CLI.record_outcome(Outcome.new(exit_code: 0))
-            end
-          end
-        end
-
-        class Cancel < BaseCommand
-          desc "Cancel a job"
-          argument :id, required: true, desc: "Job id"
-          option   :host,  required: true, desc: "Base URL of the space-server"
-          option   :token, required: true, desc: "Bearer token for authorization"
-
-          def call(id:, host: nil, token: nil, **opts)
-            setup_terminal(**opts.slice(:color, :colors))
-            handle_errors do
-              Jobs.require_credentials!(host, token)
-              result = JobsClient.new(host, token).cancel(id)
-              terminal.say JSON.pretty_generate(result)
-              CLI.record_outcome(Outcome.new(exit_code: 0))
-            end
-          end
-        end
-
-        class Watch < BaseCommand
-          desc "Resolve a job's run and stream its live events (SSE) until run_complete"
-          argument :id, required: true, desc: "Job id"
-          option   :host,  required: true, desc: "Base URL of the space-server"
-          option   :token, required: true, desc: "Bearer token for authorization"
-
-          def call(id:, host: nil, token: nil, **opts)
-            setup_terminal(**opts.slice(:color, :colors))
-            handle_errors do
-              Jobs.require_credentials!(host, token)
-              client = JobsClient.new(host, token)
-              run_id = client.wait_for_run_id(id)
-              client.stream(run_id) { |data| terminal.say data }
-              CLI.record_outcome(Outcome.new(exit_code: 0))
-            end
-          end
-        end
-      end
-
-      module Sessions
-        # See Jobs.require_credentials! above for why this is validated
-        # explicitly rather than relying on dry-cli's `required:` option flag.
-        def self.require_credentials!(host, token)
-          raise Space::Core::Error, "--host is required" unless host
-          raise Space::Core::Error, "--token or #{SessionSync::TOKEN_ENV} is required" unless token
-        end
-
-        class Sync < BaseCommand
-          desc "Scan pi/claude session files and upload new/grown conversations to a space-server"
-          option :host,        required: true, desc: "Base URL of the space-server"
-          option :token,       default: nil,   desc: "Bearer token for authorization (defaults to $#{SessionSync::TOKEN_ENV}; an explicit --token wins; an op:// ref is resolved once via `op read`)"
-          option :state_file,  default: nil,   desc: "Cursor YAML path (default: $XDG_STATE_HOME/space-architect/session-sync.yaml)"
-          option :pi_root,     default: nil,   desc: "Override the pi sessions root (default: ~/.pi/agent/sessions)"
-          option :claude_root, default: nil,   desc: "Override the claude projects root (default: ~/.claude/projects)"
-          option :dry_run,     type: :boolean, default: false, desc: "Report what would upload without uploading or recording the cursor"
-
-          def call(host: nil, token: nil, state_file: nil, pi_root: nil, claude_root: nil, dry_run: false, **opts)
-            setup_terminal(**opts.slice(:color, :colors))
-            handle_errors do
-              resolved_token = token || ENV[SessionSync::TOKEN_ENV]
-              Sessions.require_credentials!(host, resolved_token)
-              runner = SessionSync::Runner.new(
-                client: ConversationsClient.new(host, resolved_token),
-                state_path: state_file || SessionSync.default_state_file,
-                pi_root: pi_root || SessionSync.default_pi_root,
-                claude_root: claude_root || SessionSync.default_claude_root,
-                dry_run: dry_run
-              )
-              results = runner.call
-              results.each do |r|
-                terminal.say "#{r[:action]}: #{r[:path]}#{r[:action] == :failed ? " (#{r[:status]}: #{r[:errors]})" : ""}"
-              end
-              failed = results.count { |r| r[:action] == :failed }
-              terminal.say "#{results.size} file(s): #{results.size - failed} ok, #{failed} failed"
-              CLI.record_outcome(Outcome.new(exit_code: failed.zero? ? 0 : 1))
-            end
-          end
-        end
-
-        module Agent
-          module Helpers
-            def plist_path
-              File.join(SessionSync.launch_agents_dir, "#{SessionSync::LABEL}.plist")
-            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
-            include Helpers
-            desc "Install the launchd agent that periodically runs `architect sessions sync`"
-            option :host,     required: true, desc: "Base URL of the space-server"
-            option :token,    required: true, desc: "Bearer token for authorization (an op:// ref is resolved once at install time; the raw value is stored in the plist's EnvironmentVariables, not argv)"
-            option :interval, default: "900", desc: "StartInterval in seconds (default 900)"
-
-            def call(host: nil, token: nil, interval: "900", **opts)
-              setup_terminal(**opts.slice(:color, :colors))
-              handle_errors do
-                Sessions.require_credentials!(host, token)
-                resolved_token = token.start_with?("op://") ? SessionSync.resolve_token(token) : token
-                pp = plist_path
-                xml = SessionSync::Plist.call(
-                  label: SessionSync::LABEL,
-                  refresh_interval: interval.to_i,
-                  log_dir: SessionSync.log_dir,
-                  bin_path: SessionSync::BinPath.detect,
-                  ruby_bin: RbConfig.ruby,
-                  host: host,
-                  env: {SessionSync::TOKEN_ENV => resolved_token}
-                )
-                FileUtils.mkdir_p(File.dirname(pp))
-                File.write(pp, xml)
-                File.chmod(0o600, 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)}"
-                CLI.record_outcome(Outcome.new(exit_code: 0))
-              end
-            end
-          end
-
-          class Uninstall < BaseCommand
-            include Helpers
-            desc "Uninstall the session-sync launchd agent (bootout + remove the plist)"
-
-            def call(**opts)
-              setup_terminal(**opts.slice(:color, :colors))
-              handle_errors do
-                pp = plist_path
-                result = agent.new(label: SessionSync::LABEL).uninstall
-                terminal.say "bootout reported: #{format_failure(result.failure)}" if result.failure?
-
-                if File.exist?(pp)
-                  File.delete(pp)
-                  terminal.say "Removed plist: #{terminal.path(pp)}"
-                else
-                  terminal.say "Plist not present: #{terminal.path(pp)}"
-                end
-                CLI.record_outcome(Outcome.new(exit_code: 0))
-              end
-            end
-          end
-
-          class Status < BaseCommand
-            include Helpers
-            desc "Report the session-sync launchd agent's loaded/running/last-exit state"
-
-            def call(**opts)
-              setup_terminal(**opts.slice(:color, :colors))
-              handle_errors do
-                result = agent.new(label: SessionSync::LABEL).status
-                raise Space::Core::Error, "status failed: #{format_failure(result.failure)}" if result.failure?
-
-                s = result.success
-                terminal.say "label: #{SessionSync::LABEL}"
-                terminal.say "loaded: #{s[:loaded]}"
-                terminal.say "running: #{s[:running]}"
-                terminal.say "pid: #{s[:pid].inspect}"
-                terminal.say "last_exit: #{s[:last_exit].inspect}"
-                CLI.record_outcome(Outcome.new(exit_code: 0))
-              end
-            end
-          end
-        end
-      end
     end
   end
 end
@@ -1583,7 +1366,6 @@ Space::Architect::CLI::Registry.register "init",   Space::Architect::CLI::Archit
 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 "push",   Space::Architect::CLI::Architect::Push
 Space::Architect::CLI::Registry.register "sync",   Space::Architect::CLI::Architect::Sync
 Space::Architect::CLI::Registry.register "rehearse", Space::Architect::CLI::Architect::Rehearse
 Space::Architect::CLI::Registry.register "freeze", Space::Architect::CLI::Architect::Freeze
@@ -1610,19 +1392,8 @@ Space::Architect::CLI::Registry.register "worktree" do |wt|
   wt.register "remove", Space::Architect::CLI::Architect::Worktree::Remove
   wt.register "list",   Space::Architect::CLI::Architect::Worktree::List
 end
-Space::Architect::CLI::Registry.register "jobs" do |j|
-  j.register "list",   Space::Architect::CLI::Architect::Jobs::List
-  j.register "show",   Space::Architect::CLI::Architect::Jobs::Show
-  j.register "watch",  Space::Architect::CLI::Architect::Jobs::Watch
-  j.register "cancel", Space::Architect::CLI::Architect::Jobs::Cancel
-end
-Space::Architect::CLI::Registry.register "sessions" do |s|
-  s.register "sync", Space::Architect::CLI::Architect::Sessions::Sync
-  s.register "agent" do |a|
-    a.register "install",   Space::Architect::CLI::Architect::Sessions::Agent::Install
-    a.register "uninstall", Space::Architect::CLI::Architect::Sessions::Agent::Uninstall
-    a.register "status",    Space::Architect::CLI::Architect::Sessions::Agent::Status
-  end
+Space::Architect::CLI::Registry.register "routing" do |r|
+  r.register "init", Space::Architect::CLI::Architect::Routing::Init
 end
 Space::Architect::CLI::Registry.register "variant" do |v|
   v.register "add",     Space::Architect::CLI::Architect::Variant::Add