space-architect 9.2.1 → 9.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 173cd44e1e27f8fc09d46bb0d18a5c7f26138731d4315bc6db1e7cd2c704e0a4
-  data.tar.gz: cebbf1f5602efa92a9f3982f31fcc79c202549489531262cfaab3ecc1c25ba13
+  metadata.gz: 4fd0baee9b2db69fa1ef96c1b4993f75a8912b5b0898d012c13036a379e32a7f
+  data.tar.gz: 582172fa5c61e4a9419409cafdfa8701ca096a2621527141099944f3261c6592
 SHA512:
-  metadata.gz: 44430c9d2fb759035df014e4023084424b66edd6dfea696f4e0e0f555ab7d0e3d418410ae8fa117936456fd3b4ea365cf9bf217ffadbb0be184e9ccb6835526a
-  data.tar.gz: 5abb3a70daaca512e957ed2a577a45904e709be3cd05c6b57ae49f7e58ce9d612b64c33addb6ba191f49777826258e5b481e27c440bacdfd4f4e8d7f4d997dd0
+  metadata.gz: 59dd000d01b8fd0b42729d87f7f843f93690b0fbccf927e127426f352fa79aada6078a885b54e3342d3c901500fde93338be3198b77e871df85f7b28ef816f9e
+  data.tar.gz: 29f88c1fdec961ed7b53d9d9e4a3a3c156cadac2da157786bea28fca4b20b09cb786ab195d5eedf0877e11c901a2d140d66347bbee3fc52570a4a68225b78284

data/CHANGELOG.md

@@ -5,6 +5,62 @@ 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.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

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
@@ -215,41 +211,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 +521,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 +546,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 +562,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 +907,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 +923,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 +936,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)
@@ -1340,235 +1300,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 +1314,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,20 +1340,6 @@ 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
-end
 Space::Architect::CLI::Registry.register "variant" do |v|
   v.register "add",     Space::Architect::CLI::Architect::Variant::Add
   v.register "promote", Space::Architect::CLI::Architect::Variant::Promote

data/lib/space_architect/harness.rb

@@ -1,12 +1,8 @@
 # frozen_string_literal: true
 
 require "async/process"
-require "async/http/client"
-require "async/http/endpoint"
-require "protocol/http/body/writable"
 require "json"
 require "pathname"
-require "uri"
 
 module Space::Architect
   module Harness
@@ -106,8 +102,7 @@ module Space::Architect
         @guard_path = guard_path
       end
 
-      def run(prompt_path:, run_log_path:, chdir:, push_url: nil, push_token: nil,
-              push_client: nil, timeout: nil, liveness_delay: LIVENESS_DELAY_SECONDS, err: $stderr)
+      def run(prompt_path:, run_log_path:, chdir:, timeout: nil, liveness_delay: LIVENESS_DELAY_SECONDS, err: $stderr)
         prompt_path  = Pathname.new(prompt_path)
         run_log_path = Pathname.new(run_log_path)
 
@@ -117,7 +112,7 @@ module Space::Architect
             Sync do
               child = Async::Process::Child.new(*argv, chdir: chdir.to_s, in: prompt_io, out: w, err: log)
               w.close
-              tasks = start_tee(r, log, push_url: push_url, push_token: push_token, push_client: push_client, err: err)
+              tasks = [Async { drain_pipe(r, log) }]
               timed_out    = false
               timeout_task = nil
 
@@ -266,50 +261,6 @@ module Space::Architect
         # Best-effort: an internal read/parse failure must never break the run.
       end
 
-      def start_tee(r, log, push_url:, push_token:, push_client:, err: $stderr)
-        if push_url || push_client
-          body = Protocol::HTTP::Body::Writable.new(queue: Thread::SizedQueue.new(32))
-          push = Async { push_body(body, push_url: push_url, push_token: push_token, push_client: push_client, err: err) }
-          [Async { tee_pipe(r, log, body, err: err) }, push]
-        else
-          [Async { drain_pipe(r, log) }]
-        end
-      end
-
-      def push_body(body, push_url:, push_token:, push_client:, err: $stderr)
-        path    = push_url ? URI.parse(push_url).path : "/"
-        headers = [["content-type", "application/x-ndjson"]]
-        headers << ["authorization", "Bearer #{push_token}"] if push_token
-        if push_client
-          push_client.post(path, headers: headers, body: body).discard
-        else
-          Async::HTTP::Client.open(Async::HTTP::Endpoint.parse(push_url)) do |c|
-            c.post(path, headers: headers, body: body).discard
-          end
-        end
-      rescue StandardError => e
-        err.puts "push_body: transport error (best-effort, run log intact): #{e.class}: #{e.message}"
-      end
-
-      def tee_pipe(r, log, body, err: $stderr)
-        pushing = true
-        while (chunk = r.gets)
-          log.write(chunk)
-          log.flush
-          if pushing
-            begin
-              body.write(chunk)
-            rescue StandardError => e
-              err.puts "tee_pipe: push write failed (best-effort, continuing log): #{e.class}: #{e.message}"
-              pushing = false
-            end
-          end
-        end
-      ensure
-        body.close_write
-        r.close
-      end
-
       def drain_pipe(r, log)
         while (chunk = r.gets)
           log.write(chunk)

data/lib/space_architect/version.rb

@@ -2,6 +2,6 @@
 
 module Space
   module Architect
-    VERSION = "9.2.1"
+    VERSION = "9.3.0"
   end
 end

data/lib/space_architect.rb

@@ -5,14 +5,10 @@ require_relative "space_architect/version"
 
 require_relative "space_architect/harness"
 require_relative "space_architect/routing"
-require_relative "space_architect/run_creator"
-require_relative "space_architect/space_push"
 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/conversations_client"
-require_relative "space_architect/session_sync"
 require_relative "space_architect/cli"