space-architect 5.2.1 → 5.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93b3a0ea0bc130ae742448df96c9a1e884ad3ef5b75963f613d81db5029332ce
-  data.tar.gz: 9d09eecfcc005bde3a4820b1b8de40aa85dd0ce90237545001bed505779b2a0b
+  metadata.gz: de2f5d7d6f80acc7b6a7bd16c9ec3dbaf23ef9c2d425c8b1e532f5c24822533a
+  data.tar.gz: b39f07d1d24b1288d54e37a08624322ad0fc4f5a664459d6bdcbe12acf4d0438
 SHA512:
-  metadata.gz: a5e4bd5be523832721290f02ae4c3e3b790c1fe0b10cc0a70135c65675c5c162fcf201cc755914fd0fba77675562799977f05027359ead2892030c9013fd4c5c
-  data.tar.gz: '0961b982476aeacfa3be31fc6e3b5f8345ddf568ba2d76932099222a79628edb17f9a6c6ce48b57907793e61d8acb84ba80b16e0a9f166033a100c423855126f'
+  metadata.gz: 5086b34800652f32d243dce10163543a6ee182096b2a42e6938c303de99cf3fa9212591cadba7494491f04f505e16a2c569388c2434c2bbca59585ece77671a9
+  data.tar.gz: 5824a84007e85b84a19ce50c0af0ed6318315b3060caceb5ab4e560416da098d980155bbe74833560a1f7b35330bafb2e73a25e3154f28dc08cf6f53c2ed14e8

data/CHANGELOG.md

@@ -5,6 +5,33 @@ 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).
 
+## [5.3.0] - 2026-07-20
+
+### Added
+
+- **`architect sessions sync`** — scans local pi (`~/.pi/agent/sessions`) and
+  claude (`~/.claude/projects`) session stores and uploads new/grown `.jsonl`
+  files to a space-server over the bearer-authenticated `POST /conversations`
+  wire contract. Per-file `{size, mtime}` cursor at
+  `$XDG_STATE_HOME/space-architect/session-sync.yaml`, a 60-second recent-mtime
+  guard against mid-write reads, `--dry-run`, and per-file
+  uploaded/updated/skipped/failed reporting (non-zero exit on any failure).
+  An `op://` token is resolved once per run via `op read`.
+- **`architect sessions agent install|uninstall|status`** — manages a per-user
+  launchd agent (`io.github.jetpks.space-architect.session-sync`, default
+  `StartInterval` 900s) that runs the sync on an interval. An `op://` token is
+  stored in the plist as the ref, never as a resolved secret.
+- **Server: bearer branch + upsert on `POST /conversations`** — machine uploads
+  authenticate with the ingest bearer token and upsert by `(user, session_id)`:
+  re-uploading a grown session file updates the existing conversation row
+  (source file replaced, import re-enqueued) instead of duplicating it.
+  The browser upload path is unchanged.
+- **Server: run-fidelity surfaces** — the pi opening prompt is persisted and
+  rendered as a leading user turn on Runs/Show (owner-gated); runs/jobs indexes
+  carry harness/model/lane and an owner-gated prompt snippet; absolute
+  timestamps render the wire value honestly (RFC3339 offsets, millis only when
+  present).
+
 ## [5.2.1] - 2026-07-19
 
 ### Fixed

data/lib/space_architect/architect_project.rb

@@ -841,20 +841,8 @@ module Space::Architect
       raise Space::Core::Error, "No lane '#{lane}' recorded for iteration '#{iteration}'" unless lane_entry
       lane_entry = ensure_lane_materialized(iteration, lane)
 
-      model, suffix_level = Harness.parse_model_suffix(model)
-      resolved_harness, resolved_model = resolve_harness_model(harness, model,
-        stored_harness: lane_entry["harness"], stored_model: lane_entry["model"])
-
-      resolved_effort =
-        if effort
-          Harness.validate_thinking_level!(effort) unless force
-          effort
-        elsif suffix_level
-          err.puts "thinking: model suffix ':#{suffix_level}' parsed from --model → level=#{suffix_level} (model stripped to '#{model}')"
-          suffix_level
-        else
-          lane_entry["effort"]
-        end
+      resolved_harness, resolved_model, resolved_effort =
+        resolve_dispatch_harness(lane_entry, model: model, harness: harness, effort: effort, force: force, err: err)
 
       raise Space::Core::Error, "--push-host is only supported with the claude-code harness" \
         if push_host && resolved_harness != "claude-code"
@@ -870,17 +858,7 @@ module Space::Architect
 
       # --prompt: the caller authors the lane prompt anywhere (a fresh scratch file)
       # and the CLI owns the canonical copy — byte-for-byte, like variant_add.
-      if prompt
-        src = Pathname.new(prompt)
-        raise Space::Core::Error, "prompt file not found: #{src}" unless src.exist?
-        File.open(prompt_path, "wb") { |f| f.write(File.binread(src)) }
-      end
-
-      raise Space::Core::Error, "prompt.md not found: #{prompt_path}" unless prompt_path.exist?
-
-      prompt_content = prompt_path.read.strip
-      raise Space::Core::Error, "Write this lane's prompt to #{prompt_path} before dispatching." \
-        if prompt_content.empty? || prompt_content == PROMPT_STUB.strip
+      copy_and_validate_prompt!(prompt, prompt_path)
 
       bin = resolved_harness == "claude-code" ? claude_bin : opencode_bin
       harness_obj = Harness.for(resolved_harness, model: resolved_model, max_turns: max_turns, bin: bin,
@@ -941,6 +919,66 @@ module Space::Architect
       end
     end
 
+    # Submit the lane's builder run as a job to the space-server's queue instead of
+    # running it locally: the sandboxed executor mounts the lane worktree + the repo
+    # checkout at their identical host absolute paths (so the worktree's gitdir
+    # pointer resolves) and runs the harness itself — no local run.jsonl, the
+    # transcript lives server-side. jobs_client: is the injectable seam (mirrors
+    # dispatch's run_creator:).
+    def dispatch_as_job(iteration, lane, host:, token:, backend_url:, model: nil, harness: nil,
+                        max_turns: 200, effort: nil, force: false, quiet: false,
+                        job_model: nil, api_key_ref: nil, prompt: nil, jobs_client: nil, now: Time.now)
+      err = quiet ? File.open(File::NULL, "w") : $stderr
+
+      entry = slice_entry(iteration)
+      lane_entry = (entry["lanes"] || []).find { |l| l["name"] == lane }
+      raise Space::Core::Error, "No lane '#{lane}' recorded for iteration '#{iteration}'" unless lane_entry
+      lane_entry = ensure_lane_materialized(iteration, lane)
+
+      resolved_harness, resolved_model, resolved_effort =
+        resolve_dispatch_harness(lane_entry, model: model, harness: harness, effort: effort, force: force, err: err)
+      raise Space::Core::Error, "--as-job only supports the claude-code harness (lane '#{lane}' resolves to '#{resolved_harness}')" \
+        unless resolved_harness == "claude-code"
+
+      id = iteration_id(entry)
+      wt_path = space.path.join(lane_entry["worktree"] || "build/#{id}-#{lane}/wt")
+      raise Space::Core::Error, "Worktree directory does not exist: #{wt_path}" unless wt_path.exist?
+
+      build_dir   = space.path.join("build", "#{id}-#{lane}")
+      prompt_path = build_dir.join("prompt.md")
+      copy_and_validate_prompt!(prompt, prompt_path)
+
+      repo_path   = space.path.join("repos", lane_entry["repo"])
+      harness_obj = Harness.for(resolved_harness, model: resolved_model, max_turns: max_turns,
+                                                  effort: resolved_effort, force: force, err: err)
+
+      spec = job_spec(iteration: iteration, lane: lane, wt_path: wt_path, build_dir: build_dir,
+        repo_path: repo_path, prompt_content: prompt_path.read, backend_url: backend_url,
+        job_model: job_model, api_key_ref: api_key_ref, harness_args: harness_obj.builder_args)
+
+      client = jobs_client || JobsClient.new(host, token)
+      job_id = client.create(spec)
+
+      # Dispatch bookkeeping, mirroring the local path's dispatched_at stamp: a
+      # re-dispatch overwrites the prior job_id, so `architect status` always
+      # reflects the last dispatch regardless of mode.
+      update_architect_block do |b|
+        (b["iterations"] || []).each do |s|
+          next unless s["name"] == iteration
+          (s["lanes"] || []).each do |l|
+            next unless l["name"] == lane
+            l["dispatched_at"] = now.iso8601
+            l["job_id"]        = job_id
+          end
+        end
+        b
+      end
+
+      result = { job_id: job_id, spec: spec }
+      result[:prompt_copied] = prompt_path if prompt
+      result
+    end
+
     private
 
     attr_reader :space
@@ -1087,6 +1125,75 @@ module Space::Architect
       [resolved_harness, resolved_model]
     end
 
+    # --prompt: the caller authors the lane prompt anywhere (a fresh scratch file) and
+    # the CLI owns the canonical copy — byte-for-byte, like variant_add. Shared by
+    # dispatch and dispatch_as_job so both refuse the same empty/stub prompt.
+    def copy_and_validate_prompt!(prompt, prompt_path)
+      if prompt
+        src = Pathname.new(prompt)
+        raise Space::Core::Error, "prompt file not found: #{src}" unless src.exist?
+        File.open(prompt_path, "wb") { |f| f.write(File.binread(src)) }
+      end
+
+      raise Space::Core::Error, "prompt.md not found: #{prompt_path}" unless prompt_path.exist?
+
+      prompt_content = prompt_path.read.strip
+      raise Space::Core::Error, "Write this lane's prompt to #{prompt_path} before dispatching." \
+        if prompt_content.empty? || prompt_content == PROMPT_STUB.strip
+    end
+
+    # Resolve harness/model/effort for a dispatch (local or --as-job), shared so the
+    # two dispatch paths can never drift on precedence or thinking-level translation.
+    def resolve_dispatch_harness(lane_entry, model:, harness:, effort:, force:, err:)
+      model, suffix_level = Harness.parse_model_suffix(model)
+      resolved_harness, resolved_model = resolve_harness_model(harness, model,
+        stored_harness: lane_entry["harness"], stored_model: lane_entry["model"])
+
+      resolved_effort =
+        if effort
+          Harness.validate_thinking_level!(effort) unless force
+          effort
+        elsif suffix_level
+          err.puts "thinking: model suffix ':#{suffix_level}' parsed from --model → level=#{suffix_level} (model stripped to '#{model}')"
+          suffix_level
+        else
+          lane_entry["effort"]
+        end
+
+      [resolved_harness, resolved_model, resolved_effort]
+    end
+
+    # Compose a dispatch --as-job spec per the space-server's job contract: prompt +
+    # workspace.dir (the lane worktree) + environment (deps/network/mounts/env or
+    # secrets) + harness (claude/backend/args) + provenance. mounts are src:dst with
+    # src == dst — the sandboxed executor requires the lane worktree AND the repo
+    # checkout mounted at their identical host absolute paths for the worktree's
+    # gitdir pointer to resolve.
+    def job_spec(iteration:, lane:, wt_path:, build_dir:, repo_path:, prompt_content:, backend_url:,
+                job_model:, api_key_ref:, harness_args:)
+      harness = { "type" => "claude", "backend" => { "base_url" => backend_url }, "args" => harness_args }
+      harness["model"] = job_model if job_model
+      harness["backend"]["api_key_ref"] = api_key_ref if api_key_ref
+
+      environment = {
+        "env"  => api_key_ref ? {} : { "ANTHROPIC_API_KEY" => "unused-for-keyless-backends" },
+        "deps" => ["git"],
+        "permissions" => {
+          "network" => true,
+          "mounts"  => ["#{build_dir}:#{build_dir}", "#{repo_path}:#{repo_path}"]
+        }
+      }
+      environment["secrets"] = [{ "ref" => api_key_ref, "name" => "ANTHROPIC_API_KEY" }] if api_key_ref
+
+      {
+        "prompt"      => prompt_content,
+        "workspace"   => { "dir" => wt_path.to_s },
+        "environment" => environment,
+        "harness"     => harness,
+        "provenance"  => { "space" => Space::Core::Slugger.slug(space.title), "iteration" => iteration, "lane" => lane }
+      }
+    end
+
     def recorded_lane_fields(lane_entry)
       {
         harness: lane_entry["harness"] || "claude-code",

data/lib/space_architect/cli/architect.rb

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
 require "json"
+require "fileutils"
+require "space_src/launchd/agent"
+require_relative "../jobs_client"
+require_relative "../conversations_client"
+require_relative "../session_sync"
 
 module Space::Architect
   module CLI
@@ -323,49 +328,81 @@ module Space::Architect
         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)"
+        option   :as_job,     type: :boolean, default: false, desc: "Submit the run as a job to the space-server's queue instead of running locally (sandboxed executor; requires --host/--token/--backend-url)"
+        option   :host,        default: nil, desc: "Base URL of the space-server (required with --as-job)"
+        option   :token,       default: nil, desc: "Bearer token for authorization (required with --as-job)"
+        option   :backend_url, default: nil, desc: "Base URL of the harness backend the sandboxed job talks to (required with --as-job)"
+        option   :job_model,   default: nil, desc: "Model pinned for the sandboxed job's harness — distinct from --model, which is meaningless against a non-Anthropic backend"
+        option   :api_key_ref, default: nil, desc: "op:// reference resolved into ANTHROPIC_API_KEY server-side (--as-job only; omit for keyless backends)"
 
         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", push_url: nil, push_token: nil, push_host: nil,
+                 as_job: false, host: nil, token: nil, backend_url: nil, job_model: nil, api_key_ref: nil, **opts)
           setup_terminal(**opts.slice(:color, :colors))
           handle_errors do
             level = resolve_thinking_alias(effort: effort, thinking: thinking, reasoning: reasoning)
             forced_level = resolve_force_thinking_alias(force_effort: force_effort,
               force_thinking: force_thinking, force_reasoning: force_reasoning)
 
+            if as_job
+              Jobs.require_credentials!(host, token)
+              raise Space::Core::Error, "--backend-url is required with --as-job" unless backend_url
+              raise Space::Core::Error, "--as-job cannot be combined with --push-url/--push-token/--push-host/--detach" \
+                if push_url || push_token || push_host || detach
+            end
+
             render(store.find(space)) do |sp|
               project = ArchitectProject.new(space: sp)
-              kwargs = { max_turns: max_turns.to_i, detach: detach }
-              kwargs[:prompt]     = prompt          if prompt
-              kwargs[:model]      = model           if model
-              kwargs[:harness]    = harness         if harness
-              kwargs[:effort]     = forced_level || level if forced_level || level
-              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
-                terminal.say "PID:     #{res[:pid]}"
-                terminal.say "Run log: #{terminal.path(res[:run_log])}"
-                terminal.say "Report:  #{terminal.path(res[:report])}"
-                terminal.say "Dispatched detached — poll #{terminal.path(res[:report])} for completion"
+
+              if as_job
+                kwargs = { host: host, token: token, backend_url: backend_url, max_turns: max_turns.to_i }
+                kwargs[:prompt]      = prompt          if prompt
+                kwargs[:model]       = model           if model
+                kwargs[:harness]     = harness         if harness
+                kwargs[:effort]      = forced_level || level if forced_level || level
+                kwargs[:force]       = true            if forced_level
+                kwargs[:quiet]       = true             if quiet
+                kwargs[:job_model]   = job_model       if job_model
+                kwargs[:api_key_ref] = api_key_ref     if api_key_ref
+                res = project.dispatch_as_job(iteration, lane, **kwargs)
+                terminal.say "Prompt:  #{prompt} → #{terminal.path(res[:prompt_copied])}" if res[:prompt_copied]
+                terminal.say "Job:     #{res[:job_id]}"
+                terminal.say "Watch:   architect jobs watch #{res[:job_id]} --host #{host} --token #{token}"
                 CLI.record_outcome(Outcome.new(exit_code: 0))
-              elsif res[:timed_out]
-                terminal.say "Run log: #{terminal.path(res[:run_log])}"
-                terminal.say "Report:  #{terminal.path(res[:report])}"
-                terminal.say "Builder TIMED OUT after #{timeout}s — process group killed. Re-dispatch (lanes are cheap)."
-                CLI.record_outcome(Outcome.new(exit_code: res[:exit_code]))
               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]}"
-                CLI.record_outcome(Outcome.new(exit_code: res[:exit_code]))
+                kwargs = { max_turns: max_turns.to_i, detach: detach }
+                kwargs[:prompt]     = prompt          if prompt
+                kwargs[:model]      = model           if model
+                kwargs[:harness]    = harness         if harness
+                kwargs[:effort]     = forced_level || level if forced_level || level
+                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
+                  terminal.say "PID:     #{res[:pid]}"
+                  terminal.say "Run log: #{terminal.path(res[:run_log])}"
+                  terminal.say "Report:  #{terminal.path(res[:report])}"
+                  terminal.say "Dispatched detached — poll #{terminal.path(res[:report])} for completion"
+                  CLI.record_outcome(Outcome.new(exit_code: 0))
+                elsif res[:timed_out]
+                  terminal.say "Run log: #{terminal.path(res[:run_log])}"
+                  terminal.say "Report:  #{terminal.path(res[:report])}"
+                  terminal.say "Builder TIMED OUT after #{timeout}s — process group killed. Re-dispatch (lanes are cheap)."
+                  CLI.record_outcome(Outcome.new(exit_code: res[:exit_code]))
+                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]}"
+                  CLI.record_outcome(Outcome.new(exit_code: res[:exit_code]))
+                end
               end
             end
           end
@@ -821,6 +858,217 @@ 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 { |j| [j["id"], j["status"], j["run_id"], j["created_at"]] }
+                terminal.say terminal.table(%w[ID Status RunID CreatedAt], 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 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,       required: true, desc: "Bearer token for authorization (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
+              Sessions.require_credentials!(host, token)
+              runner = SessionSync::Runner.new(
+                client: ConversationsClient.new(host, 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
+          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 stored as-is in the plist)"
+            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)
+                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,
+                  host: host,
+                  token: token
+                )
+                FileUtils.mkdir_p(File.dirname(pp))
+                File.write(pp, xml)
+
+                result = Space::Src::Launchd::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 = Space::Src::Launchd::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 = Space::Src::Launchd::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
@@ -854,6 +1102,20 @@ 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/conversations_client.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "async/http/client"
+require "async/http/endpoint"
+require "json"
+require "securerandom"
+
+module Space::Architect
+  # HTTP client for the space-server conversations upload API, modeled on
+  # JobsClient: Bearer auth, injectable async-http client. Unlike JobsClient,
+  # a non-2xx response is returned to the caller (not raised) — SessionSync
+  # needs to distinguish created/updated/failed per file without aborting
+  # the whole run on one bad upload.
+  class ConversationsClient
+    def initialize(host, token, client: nil, op_resolver: nil)
+      @host = host.chomp("/")
+      @token = token
+      @client = client
+      @op_resolver = op_resolver || method(:op_read)
+      @resolved_token = nil
+    end
+
+    # POST /conversations — multipart per the frozen wire contract:
+    # conversation[source_file] (the file), conversation[session_id].
+    # Returns {status:, conversation_id:, action:, errors:}.
+    def upload(path:, session_id:)
+      Sync do
+        with_client do |c|
+          boundary = "ArchitectBoundary#{SecureRandom.hex(8)}"
+          body = build_multipart(boundary, path, session_id)
+          response = c.post("/conversations", headers: headers(boundary), body: body)
+          status = response.status
+          parsed = begin
+            JSON.parse(response.read || "{}")
+          rescue JSON::ParserError
+            {}
+          end
+          {status: status, conversation_id: parsed["conversation_id"], action: parsed["action"], errors: parsed["errors"]}
+        end
+      end
+    end
+
+    private
+
+    def with_client
+      if @client
+        yield @client
+      else
+        Async::HTTP::Client.open(Async::HTTP::Endpoint.parse(@host)) { |c| yield c }
+      end
+    end
+
+    def headers(boundary)
+      [
+        ["authorization", "Bearer #{resolved_token}"],
+        ["content-type", "multipart/form-data; boundary=#{boundary}"]
+      ]
+    end
+
+    # Resolved once per client instance (per run), per spec.
+    def resolved_token
+      @resolved_token ||= @token.start_with?("op://") ? @op_resolver.call(@token) : @token
+    end
+
+    def op_read(ref)
+      value = IO.popen(["op", "read", ref], &:read)
+      raise Space::Core::Error, "op read failed for #{ref}" unless $?.success?
+
+      value.chomp
+    end
+
+    def build_multipart(boundary, path, session_id)
+      crlf = "\r\n"
+      filename = File.basename(path)
+      file_content = File.binread(path)
+      +"--#{boundary}#{crlf}" \
+        "Content-Disposition: form-data; name=\"conversation[source_file]\"; filename=\"#{filename}\"#{crlf}" \
+        "Content-Type: application/octet-stream#{crlf}" \
+        "#{crlf}" \
+        "#{file_content}#{crlf}" \
+        "--#{boundary}#{crlf}" \
+        "Content-Disposition: form-data; name=\"conversation[session_id]\"#{crlf}" \
+        "#{crlf}" \
+        "#{session_id}#{crlf}" \
+        "--#{boundary}--#{crlf}"
+    end
+  end
+end

data/lib/space_architect/harness.rb

@@ -188,6 +188,23 @@ module Space::Architect
         pid
       end
 
+      # The builder flag set independent of prompt delivery, --model, and the
+      # --output-format/--verbose pair — a sandboxed `dispatch --as-job` executor
+      # supplies -p/the prompt/--model/--output-format itself (see the space-server's
+      # SandboxArgv#build), so JobsClient spec composition reuses this verbatim
+      # instead of duplicating a second flag list (DRY).
+      def builder_args
+        args = [
+          "--permission-mode", "acceptEdits",
+          "--allowedTools", @allowed_tools,
+          "--include-partial-messages",
+          "--max-turns", @max_turns.to_s
+        ]
+        args += ["--disallowedTools", @disallowed_tools] unless @disallowed_tools.to_s.empty?
+        args += ["--effort", @effort] if @effort
+        args
+      end
+
       private
 
       # Read the run log's stream-json init event and print exactly one bounded liveness
@@ -227,19 +244,7 @@ module Space::Architect
       end
 
       def argv
-        args = [
-          @bin, "-p",
-          "--model", @model,
-          "--permission-mode", "acceptEdits",
-          "--allowedTools", @allowed_tools,
-          "--output-format", "stream-json",
-          "--verbose",
-          "--include-partial-messages",
-          "--max-turns", @max_turns.to_s
-        ]
-        args += ["--disallowedTools", @disallowed_tools] unless @disallowed_tools.to_s.empty?
-        args += ["--effort", @effort] if @effort
-        args
+        [@bin, "-p", "--model", @model, "--output-format", "stream-json", "--verbose"] + builder_args
       end
 
       def start_tee(r, log, push_url:, push_token:, push_client:, err: $stderr)

data/lib/space_architect/jobs_client.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "async/http/client"
+require "async/http/endpoint"
+require "json"
+
+module Space::Architect
+  # HTTP client for the space-server jobs API, modeled on RunCreator: Bearer
+  # auth, injectable async-http client, Space::Core::Error on any failure.
+  class JobsClient
+    # Poll bound for #wait_for_run_id: 2s * 30 attempts = 60s. Both are
+    # injectable kwargs so tests need not sleep real seconds.
+    POLL_INTERVAL_SECONDS = 2
+    POLL_MAX_ATTEMPTS     = 30
+
+    def initialize(host, token, client: nil)
+      @host   = host.chomp("/")
+      @token  = token
+      @client = client
+    end
+
+    # GET /jobs — returns the "jobs" array (owner-scoped, newest-first).
+    def list
+      get_json("/jobs")["jobs"]
+    end
+
+    # GET /jobs/:id — returns the job JSON.
+    def show(id)
+      get_json("/jobs/#{id}")
+    end
+
+    # POST /jobs — submits a job spec (harness/prompt/environment) and returns the
+    # created job's integer id. Raises Space::Core::Error on any failure, modeled on
+    # RunCreator#create (same 20x-status + integer-id checks).
+    def create(spec)
+      Sync do
+        with_client do |c|
+          response = c.post("/jobs", headers: headers, body: JSON.generate(spec))
+          parsed   = parse_json(response, "POST /jobs", expected_status: 201)
+          id       = parsed["id"]
+          raise Space::Core::Error, "POST /jobs: missing or non-integer id in response: #{parsed.inspect[0, 200]}" \
+            unless id.is_a?(Integer)
+
+          id
+        end
+      end
+    end
+
+    # POST /jobs/:id/cancel — returns {"id"=>.., "status"=>"canceled"}.
+    def cancel(id)
+      Sync do
+        with_client do |c|
+          response = c.post("/jobs/#{id}/cancel", headers: headers, body: nil)
+          parse_json(response, "POST /jobs/#{id}/cancel")
+        end
+      end
+    end
+
+    # GET /runs/:id/stream — yields each SSE event's data: payload to the
+    # block as it arrives. Returns when the stream reports run_complete or
+    # closes cleanly. Raises Space::Core::Error on a non-200 response.
+    def stream(run_id, &block)
+      Sync do
+        with_client do |c|
+          response = c.get("/runs/#{run_id}/stream", headers: headers)
+          unless response.status == 200
+            body = response.read || ""
+            raise Space::Core::Error, "GET /runs/#{run_id}/stream failed (#{response.status}): #{body[0, 200]}"
+          end
+
+          read_sse(response, &block)
+        end
+      end
+    end
+
+    # Polls GET /jobs/:id until run_id is present, waiting `interval` seconds
+    # between attempts, up to `attempts` tries. Raises Space::Core::Error if
+    # the bound is exceeded.
+    def wait_for_run_id(id, interval: POLL_INTERVAL_SECONDS, attempts: POLL_MAX_ATTEMPTS)
+      attempts.times do |i|
+        run_id = show(id)["run_id"]
+        return run_id if run_id
+        sleep interval unless i == attempts - 1
+      end
+      raise Space::Core::Error, "job #{id}: no run_id after #{attempts} attempts (#{attempts * interval}s)"
+    end
+
+    private
+
+    def get_json(path)
+      Sync do
+        with_client do |c|
+          response = c.get(path, headers: headers)
+          parse_json(response, "GET #{path}")
+        end
+      end
+    end
+
+    def with_client
+      if @client
+        yield @client
+      else
+        Async::HTTP::Client.open(Async::HTTP::Endpoint.parse(@host)) { |c| yield c }
+      end
+    end
+
+    def headers
+      [
+        ["authorization", "Bearer #{@token}"],
+        ["content-type",  "application/json"]
+      ]
+    end
+
+    def parse_json(response, what, expected_status: 200)
+      status = response.status
+      body   = response.read || ""
+      raise Space::Core::Error, "#{what} failed (#{status}): #{body[0, 200]}" unless status == expected_status
+
+      JSON.parse(body)
+    end
+
+    # Buffers chunks and splits on the SSE event terminator ("\n\n"). Each
+    # event's data: line(s) are joined and yielded; an event whose data JSON
+    # carries type == "run_complete" ends the stream.
+    def read_sse(response)
+      buffer = +""
+      response.each do |chunk|
+        buffer << chunk
+        while (boundary = buffer.index("\n\n"))
+          event = buffer.slice!(0..boundary + 1)
+          data  = event.each_line.select { |line| line.start_with?("data:") }
+                        .map { |line| line.sub(/\Adata:\s?/, "").chomp }
+                        .join("\n")
+          next if data.empty?
+
+          yield data
+          parsed = begin
+            JSON.parse(data)
+          rescue JSON::ParserError
+            nil
+          end
+          return if parsed.is_a?(Hash) && parsed["type"] == "run_complete"
+        end
+      end
+    end
+  end
+end

data/lib/space_architect/session_sync/bin_path.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+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
+    # detect_bin_path precedence: an env override (tests), the dev checkout's
+    # exe/architect, `which architect`, then the installed gem's bin.
+    module BinPath
+      module_function
+
+      def detect(env: ENV)
+        override = env["SPACE_ARCHITECT_BIN_PATH"]
+        return override if override && !override.empty?
+
+        dev = File.expand_path("../../../exe/architect", __dir__)
+        return dev if File.exist?(dev)
+
+        out, _err, status = Open3.capture3("which", "architect")
+        return out.strip if status.success? && !out.strip.empty?
+
+        Gem.bin_path("space-architect", "architect")
+      end
+    end
+  end
+end

data/lib/space_architect/session_sync/cursor.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "yaml"
+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
+    # absolute source path; each entry records the size + mtime observed the
+    # last time that file was uploaded.
+    class Cursor
+      Entry = Data.define(:size, :mtime) do
+        def initialize(size:, mtime:) = super
+      end
+
+      def self.load(path)
+        raw = read_yaml(path)
+        raw.each_with_object({}) do |(k, v), acc|
+          acc[k] = Entry.new(size: v["size"], mtime: v["mtime"])
+        end
+      end
+
+      def self.write(path, entries)
+        FileUtils.mkdir_p(File.dirname(path))
+        payload = entries.each_with_object({}) { |(k, v), acc| acc[k] = {"size" => v.size, "mtime" => v.mtime} }
+        tmp = "#{path}.tmp.#{Process.pid}"
+        begin
+          File.write(tmp, YAML.dump(payload, line_width: -1))
+          File.rename(tmp, path)
+        ensure
+          File.delete(tmp) if File.exist?(tmp)
+        end
+      end
+
+      def self.read_yaml(path)
+        return {} unless File.exist?(path)
+
+        YAML.safe_load_file(path, permitted_classes: [], aliases: false) || {}
+      end
+    end
+  end
+end

data/lib/space_architect/session_sync/plist.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Space::Architect
+  module SessionSync
+    # Hand-rolled launchd plist emitter for the session-sync agent, imitating
+    # Space::Src::Launchd::Plist's shape. Unlike that emitter, this one does
+    # NOT wrap the invocation in mise/ruby toolchain resolution: the
+    # `architect` executable is a rubygems binstub (or the dev exe/architect
+    # script, which sets up Bundler itself) and needs no toolchain pinning to
+    # run non-interactively, so ProgramArguments invokes it directly.
+    class Plist
+      HEADER = <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+      XML
+      FOOTER = "</dict>\n</plist>\n"
+
+      class << self
+        # @param label [String]            The job label (reverse-DNS; on-disk plist basename).
+        # @param refresh_interval [Integer] StartInterval in seconds (must be > 0).
+        # @param log_dir [String]          Absolute directory for stdout/stderr logs.
+        # @param bin_path [String]         Absolute path to the architect bin script.
+        # @param host [String]             --host value passed to `sessions sync`.
+        # @param token [String]            --token value passed to `sessions sync` (an op:// ref
+        #                                  is passed through verbatim — never resolved here).
+        # @return [String] the full plist XML.
+        def call(label:, refresh_interval:, log_dir:, bin_path:, host:, token:)
+          raise ArgumentError, "label is required" if label.to_s.empty?
+          raise ArgumentError, "refresh_interval must be > 0" unless refresh_interval.is_a?(Integer) && refresh_interval > 0
+          %w[log_dir bin_path].each do |k|
+            v = binding.local_variable_get(k)
+            raise ArgumentError, "#{k} must be absolute (got #{v.inspect})" unless v.is_a?(String) && File.absolute_path?(v)
+          end
+          raise ArgumentError, "host is required" if host.to_s.empty?
+          raise ArgumentError, "token is required" if token.to_s.empty?
+
+          out_log = File.join(log_dir, "#{label}.out.log")
+          err_log = File.join(log_dir, "#{label}.err.log")
+
+          body = +""
+          body << key("Label") << string(label) << "\n"
+          body << key("ProgramArguments") << "\n" << array([
+            bin_path,
+            "sessions",
+            "sync",
+            "--host", host,
+            "--token", token
+          ])
+          body << key("StartInterval") << integer(refresh_interval) << "\n"
+          body << key("RunAtLoad") << boolean(true) << "\n"
+          body << key("ProcessType") << string("Background") << "\n"
+          body << key("StandardOutPath") << string(out_log) << "\n"
+          body << key("StandardErrorPath") << string(err_log) << "\n"
+
+          HEADER + body + FOOTER
+        end
+
+        private
+
+        def key(name)
+          "  <key>#{escape(name)}</key>\n"
+        end
+
+        def escape(s)
+          s.to_s
+            .gsub("&", "&amp;")
+            .gsub("<", "&lt;")
+            .gsub(">", "&gt;")
+            .gsub("\"", "&quot;")
+            .gsub("'", "&apos;")
+        end
+
+        def string(s)
+          "  <string>#{escape(s)}</string>"
+        end
+
+        def integer(i)
+          "  <integer>#{Integer(i)}</integer>"
+        end
+
+        def boolean(b)
+          "  <#{b ? "true" : "false"}/>"
+        end
+
+        def array(items)
+          out = +"  <array>\n"
+          items.each { |arg| out << "    <string>#{escape(arg)}</string>\n" }
+          out << "  </array>"
+        end
+      end
+    end
+  end
+end

data/lib/space_architect/session_sync/runner.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "cursor"
+require_relative "session_id"
+
+module Space::Architect
+  module SessionSync
+    # One sync pass: scans the pi + claude session roots, decides
+    # upload/skip per the frozen cursor rules, uploads via the injected
+    # client, and persists the updated cursor (unless dry_run).
+    class Runner
+      RECENT_MTIME_SECONDS = 60
+
+      def initialize(client:, state_path:, pi_root:, claude_root:, now: -> { Time.now }, dry_run: false)
+        @client = client
+        @state_path = state_path
+        @pi_root = pi_root
+        @claude_root = claude_root
+        @now = now
+        @dry_run = dry_run
+      end
+
+      def call
+        cursor = Cursor.load(@state_path)
+        results = files.map { |path, session_id| process(path, session_id, cursor) }
+        Cursor.write(@state_path, cursor) unless @dry_run
+        results
+      end
+
+      private
+
+      def process(path, session_id, cursor)
+        stat = File.stat(path)
+        recorded = cursor[path]
+
+        return {path: path, session_id: session_id, action: :skipped, reason: "recent mtime"} if recent_mtime?(stat)
+        return {path: path, session_id: session_id, action: :skipped, reason: "unchanged"} if recorded && recorded.size >= stat.size
+
+        return {path: path, session_id: session_id, action: :would_upload} if @dry_run
+
+        response = @client.upload(path: path, session_id: session_id)
+        if [200, 201].include?(response[:status])
+          cursor[path] = Cursor::Entry.new(size: stat.size, mtime: stat.mtime.to_i)
+          {path: path, session_id: session_id, action: response[:status] == 201 ? :uploaded : :updated,
+           conversation_id: response[:conversation_id]}
+        else
+          {path: path, session_id: session_id, action: :failed, status: response[:status], errors: response[:errors]}
+        end
+      end
+
+      def recent_mtime?(stat)
+        (@now.call - stat.mtime) < RECENT_MTIME_SECONDS
+      end
+
+      def files
+        pi = Dir.glob(File.join(@pi_root, "**", "*.jsonl")).map { |p| [p, SessionId.for_pi(p)] }
+        claude = Dir.glob(File.join(@claude_root, "**", "*.jsonl")).map { |p| [p, SessionId.for_claude(p)] }
+        pi + claude
+      end
+    end
+  end
+end

data/lib/space_architect/session_sync/session_id.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Space::Architect
+  module SessionSync
+    # Frozen session-id derivation rules for the two store shapes:
+    #   pi:     <mangled-cwd>/<timestamp>_<sessionId>.jsonl -> part after the last "_"
+    #   claude: <mangled-cwd>/<sessionId>.jsonl             -> basename minus ".jsonl"
+    module SessionId
+      def self.for_pi(path)
+        base = File.basename(path, ".jsonl")
+        idx = base.rindex("_")
+        idx ? base[(idx + 1)..] : base
+      end
+
+      def self.for_claude(path)
+        File.basename(path, ".jsonl")
+      end
+    end
+  end
+end

data/lib/space_architect/session_sync.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "session_sync/session_id"
+require_relative "session_sync/cursor"
+require_relative "session_sync/runner"
+require_relative "session_sync/plist"
+require_relative "session_sync/bin_path"
+
+module Space::Architect
+  # Session-sync rail's laptop half: scans ~/.pi/agent/sessions/**/*.jsonl and
+  # ~/.claude/projects/**/*.jsonl for conversation files, uploads new/grown
+  # ones to a space-server via ConversationsClient, and installs a per-user
+  # launchd agent that runs the sync on an interval. Opencode (sqlite) is out
+  # of scope for this rail.
+  module SessionSync
+    LABEL = "io.github.jetpks.space-architect.session-sync"
+    APP_NAME = "space-architect"
+
+    module_function
+
+    def state_dir(env: ENV)
+      File.join(Space::Core::XDG.state_home(env: env).to_s, APP_NAME)
+    end
+
+    def default_state_file(env: ENV)
+      File.join(state_dir(env: env), "session-sync.yaml")
+    end
+
+    def default_pi_root(env: ENV)
+      File.join(Space::Core::XDG.home(env: env), ".pi", "agent", "sessions")
+    end
+
+    def default_claude_root(env: ENV)
+      File.join(Space::Core::XDG.home(env: env), ".claude", "projects")
+    end
+
+    def log_dir(env: ENV)
+      File.join(state_dir(env: env), "logs")
+    end
+
+    def launch_agents_dir(env: ENV)
+      File.join(Space::Core::XDG.home(env: env), "Library", "LaunchAgents")
+    end
+  end
+end

data/lib/space_architect.rb

@@ -12,4 +12,6 @@ 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"

data/lib/space_core/version.rb

@@ -2,6 +2,6 @@
 
 module Space
   module Core
-    VERSION = "5.2.1"
+    VERSION = "5.3.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: space-architect
 version: !ruby/object:Gem::Version
-  version: 5.2.1
+  version: 5.3.0
 platform: ruby
 authors:
 - Eric Jacobs
@@ -260,10 +260,12 @@ files:
 - lib/space_architect/cli/research.rb
 - lib/space_architect/cli/space.rb
 - lib/space_architect/cli/src.rb
+- lib/space_architect/conversations_client.rb
 - lib/space_architect/dispatcher.rb
 - lib/space_architect/gate_evaluator.rb
 - lib/space_architect/gate_lint.rb
 - lib/space_architect/harness.rb
+- lib/space_architect/jobs_client.rb
 - lib/space_architect/research.rb
 - lib/space_architect/research/mux.rb
 - lib/space_architect/research/registry.rb
@@ -271,6 +273,12 @@ files:
 - lib/space_architect/research/run.rb
 - lib/space_architect/research/supervisor.rb
 - lib/space_architect/run_creator.rb
+- lib/space_architect/session_sync.rb
+- lib/space_architect/session_sync/bin_path.rb
+- lib/space_architect/session_sync/cursor.rb
+- lib/space_architect/session_sync/plist.rb
+- lib/space_architect/session_sync/runner.rb
+- lib/space_architect/session_sync/session_id.rb
 - lib/space_architect/skill_installer.rb
 - lib/space_architect/templates/architect.md.erb
 - lib/space_architect/templates/brief.md.erb