claude-inbox 0.1.0 → 0.3.0

data/exe/claude-inbox

@@ -9,25 +9,43 @@ if ARGV.include?("--version")
 end
 
 require "claude_inbox/app"
+require "claude_inbox/config"
+require "tmpdir"
+
+fixture = ARGV.include?("--fixture")
+# A fixture run takes the listen flags, for trying the API with curl, but
+# not the environment or the config file, which are for the real inbox.
+begin
+  argv = fixture ? ARGV : ClaudeInbox::Config.argv(ARGV)
+  listen = ClaudeInbox::Remote::Listener.options(argv, fixture ? {} : ENV)
+rescue ArgumentError => e
+  abort "claude-inbox: #{e.message}"
+end
 
 # Crash traces go here instead of the alt screen when set.
 $stderr.reopen(ENV["CLAUDE_INBOX_STDERR"], "a") if ENV["CLAUDE_INBOX_STDERR"]
 
 opts = {}
-if (i = ARGV.index("--fixture"))
-  agents = ARGV[i + 1]
+if fixture
+  agents = argv[argv.index("--fixture") + 1]
   fixtures = File.dirname(agents)
   opts[:client] = ClaudeInbox::FixtureClient.new(agents, logs: File.binread(File.join(fixtures, "logs_raw.txt")))
   opts[:store] = ClaudeInbox::Store.new(path: nil)
-  opts[:jobs_dir] = File.join(fixtures, "jobs")
   opts[:pull_requests] = ClaudeInbox::PullRequests.new(cache_path: File.join(fixtures, "gh-pr-status-cache.json"), resolved_path: nil, gh: nil)
+  # Its own token, lock and images, so a test inbox can neither rotate the
+  # token phones are paired with nor hold the real inbox's lock.
+  dir = File.join(Dir.tmpdir, "claude-inbox-fixture")
+  opts[:listen] = listen&.merge(fixture: true, pairing: ClaudeInbox::Remote::Pairing.new(path: File.join(dir, "listen.json")),
+    lock_path: File.join(dir, "listen.lock"), images_dir: File.join(dir, "images"))
 else
   # The only place the reaper is armed. Everything else — tests, --fixture,
-  # anything embedding App — gets one that deletes nothing.
+  # anything embedding App — gets one that deletes nothing. The listener,
+  # likewise, comes only from this file, and only when asked for.
   opts[:client] = ClaudeInbox::AgentsClient.new
   opts[:store] = ClaudeInbox::Store.new
   opts[:reaper] = ClaudeInbox::Reaper.new(opts[:client], opts[:store])
+  opts[:listen] = listen
 end
-opts[:color] = false if ARGV.include?("--no-color")
+opts[:color] = false if argv.include?("--no-color")
 
 ClaudeInbox::App.new(**opts).run

data/lib/claude_inbox/agents_client.rb

@@ -2,6 +2,7 @@
 
 require "json"
 require_relative "debug"
+require_relative "job_state"
 require_relative "subprocess"
 
 module ClaudeInbox
@@ -10,8 +11,11 @@ module ClaudeInbox
   class AgentsClient
     class Error < StandardError; end
 
-    def initialize(bin: "claude")
+    attr_reader :jobs_dir
+
+    def initialize(bin: "claude", jobs_dir: JobState::DEFAULT_DIR)
       @bin = bin
+      @jobs_dir = jobs_dir
     end
 
     # => Array<Session>
@@ -42,7 +46,7 @@ module ClaudeInbox
     # and, the moment it becomes the agents view, terminate it. The user then
     # lands back in the inbox instead of native agent view.
     def attach(id)
-      pid = Process.spawn(@bin, "attach", id)
+      pid = Process.spawn(*Subprocess.command(@bin, "attach", id))
       watchdog = Thread.new { kill_when_agents_view(pid) }
       _, status = Process.wait2(pid)
       status
@@ -60,10 +64,7 @@ module ClaudeInbox
 
     # Start a background session. Returns its short id.
     def spawn(prompt:, cwd:, **opts)
-      argv = self.class.spawn_args(@bin, prompt: prompt, **opts)
-      r = Subprocess.capture(*argv, chdir: cwd)
-      raise Error, "claude --bg failed: #{(r.err + r.out).strip}" unless r.success?
-      r.out[/\b[0-9a-f]{8}\b/] || r.out.strip
+      start_bg(self.class.spawn_args(@bin, prompt: prompt, **opts), cwd, "claude --bg")
     end
 
     # How a prompt attaches a file: the same @ mention the CLI's own prompt
@@ -71,45 +72,44 @@ module ClaudeInbox
     # its path completion escapes them; a quoted path is not recognized.
     def self.mention(path) = "@" + path.gsub(" ", "\\ ")
 
-    # Pure so it can be tested: "default" means leave the flag off.
-    def self.spawn_args(bin, prompt:, model: nil, effort: nil, permission_mode: nil, worktree: false, name: nil)
-      argv = [bin, "--bg", prompt]
-      argv += ["--model", model] if model && model != "default"
-      argv += ["--effort", effort] if effort && effort != "default"
-      argv += ["--permission-mode", permission_mode] if permission_mode && permission_mode != "default"
+    # Pure so it can be tested: a setting left nil leaves its flag off. The
+    # prompt goes after "--", where a leading dash is text rather than an
+    # unknown option, and --remote-control sits just before it: its optional
+    # name would otherwise eat the prompt (both checked on 2.1.282).
+    def self.spawn_args(bin, prompt:, model: nil, effort: nil, permission_mode: nil, worktree: false, name: nil, remote: false)
+      argv = [bin, "--bg"]
+      {"--model" => model, "--effort" => effort, "--permission-mode" => permission_mode}.each do |flag, value|
+        argv += [flag, value] if value
+      end
       argv += ["--name", name] if name && !name.strip.empty?
       argv << "--worktree" if worktree
-      argv
+      argv << "--remote-control" if remote
+      argv + ["--", prompt]
     end
 
-    def parse(json)
-      JSON.parse(json).map { |h| Session.from_hash(h) }
+    # Pull a conversation a `claude remote-control` server is serving into
+    # the daemon, as a background session under the same id. Returns the
+    # short id. The worker goes first: while it is open, a resume only makes
+    # a copy. The server marks the session failed and leaves it be; the
+    # resumed session gets a bridge of its own.
+    def adopt(session_id:, cwd:, pid:)
+      raise Error, "nothing to adopt yet — send it a message from your phone first" if transcript_empty?(cwd, session_id)
+      Process.kill("TERM", pid)
+      wait_gone(pid)
+      start_bg(self.class.adopt_args(@bin, session_id), cwd, "claude --bg --resume")
     end
 
-    # Flags that mark a claude process as one a program drives rather than one
-    # you type in: the headless print mode and the SDK's stream protocol.
-    HEADLESS_FLAGS = %w[-p --print --input-format --output-format].freeze
+    def self.adopt_args(bin, session_id) = [bin, "--bg", "--resume", session_id, "--remote-control"]
 
-    # The JSON reports Remote Control workers, local sub-agents and headless
-    # runs as `interactive`, same as a terminal you opened yourself, each named
-    # after its directory. The process tree tells them apart; see `origins`.
-    # Everything but a terminal and a remote worker is dropped here rather than
-    # merely flagged: attach lands on the session that asked for it, so there
-    # is nothing useful to show or act on directly.
-    def classify_origins(sessions)
-      pids = sessions.select { |s| s.interactive? && s.pid }.map(&:pid)
-      return sessions if pids.empty?
-      assign_origins(sessions, origins_by_pid(pids))
+    # Where the CLI keeps a directory's transcripts: every slash and dot in
+    # the path becomes a dash.
+    def self.transcript_path(cwd, session_id, home: Dir.home)
+      File.join(home, ".claude", "projects", cwd.gsub(%r{[/.]}, "-"), "#{session_id}.jsonl")
     end
 
-    # Tags each interactive session with where it is driven from (pid =>
-    # origin, terminal when unlisted) and drops the unattended ones, whose
-    # parent is the row worth showing.
-    def assign_origins(sessions, origins)
-      sessions
-        .map { |s| s.interactive? ? s.with(origin: origins.fetch(s.pid, :terminal)) : s }
-        .reject(&:unattended?)
-    end
+    # Flags that mark a claude process as one a program drives rather than one
+    # you type in: the headless print mode and the SDK's stream protocol.
+    HEADLESS_FLAGS = %w[-p --print --input-format --output-format].freeze
 
     # pid => origin, given `ps` for the sessions and for their parents. Pure.
     #
@@ -137,12 +137,63 @@ module ClaudeInbox
     # terminal often enough to matter; the false positive is accepted.
     def self.headless?(cmd) = cmd.split.drop(1).any? { |arg| HEADLESS_FLAGS.include?(arg) }
 
-    def origins_by_pid(pids)
+    # pid => bridge session id, for the workers a `claude remote-control`
+    # server spawned: each is started with `--session-id cse_…`, the same id
+    # a background session records as bridgeSessionId. Pure.
+    def self.bridge_ids(rows)
+      rows.filter_map { |pid, _, cmd| (m = cmd.match(/--session-id[= ](cse_\w+)/)) && [pid, m[1]] }.to_h
+    end
+
+    private
+
+    # A worker nobody has messaged yet has an empty file, and the daemon
+    # reports "source session not found" on resuming it.
+    def transcript_empty?(cwd, session_id)
+      path = self.class.transcript_path(cwd, session_id)
+      File.exist?(path) && File.zero?(path)
+    end
+
+    def wait_gone(pid, timeout: 5)
+      deadline = Time.now + timeout
+      while Time.now < deadline
+        Process.kill(0, pid)
+        sleep 0.1
+      end
+      raise Error, "the worker #{pid} would not exit"
+    rescue Errno::ESRCH
+      nil
+    end
+
+    def parse(json)
+      JSON.parse(json).map { |h| Session.from_hash(h) }
+    end
+
+    # The JSON reports Remote Control workers, local sub-agents and headless
+    # runs as `interactive`, same as a terminal you opened yourself, each named
+    # after its directory. The process tree tells them apart; see `origins`.
+    # Everything but a terminal and a remote worker is dropped here rather than
+    # merely flagged: attach lands on the session that asked for it, so there
+    # is nothing useful to show or act on directly.
+    def classify_origins(sessions)
+      pids = sessions.select { |s| s.interactive? && s.pid }.map(&:pid)
+      return sessions if pids.empty?
       rows = ps_rows(pids)
+      assign_origins(sessions, origins_from(rows), self.class.bridge_ids(rows))
+    end
+
+    # Tags each interactive session with where it is driven from (pid =>
+    # origin, terminal when unlisted) and the bridge a remote one is served
+    # over, and drops the unattended ones, whose parent is the row worth
+    # showing.
+    def assign_origins(sessions, origins, bridges = {})
+      sessions
+        .map { |s| s.interactive? ? s.with(origin: origins.fetch(s.pid, :terminal), bridge_id: bridges[s.pid]) : s }
+        .reject(&:unattended?)
+    end
+
+    def origins_from(rows)
       return {} if rows.empty?
       self.class.origins(rows, ps_commands(rows.map { |_, ppid, _| ppid }.uniq))
-    rescue Errno::ENOENT
-      {}
     end
 
     def ps_rows(pids)
@@ -152,6 +203,8 @@ module ClaudeInbox
         pid, ppid, *cmd = l.split
         [pid.to_i, ppid.to_i, cmd.join(" ")]
       }
+    rescue Errno::ENOENT
+      []
     end
 
     # pid => command, for the given parent pids.
@@ -165,8 +218,6 @@ module ClaudeInbox
       }
     end
 
-    private
-
     def kill_when_agents_view(pid)
       loop do
         sleep WATCH_INTERVAL
@@ -188,22 +239,29 @@ module ClaudeInbox
       raise Error, "#{argv[1]} failed: #{r.err.strip}" unless r.success?
       true
     end
+
+    def start_bg(argv, cwd, what)
+      r = Subprocess.capture(*argv, chdir: cwd)
+      raise Error, "#{what} failed: #{(r.err + r.out).strip}" unless r.success?
+      r.out[/\b[0-9a-f]{8}\b/] || r.out.strip
+    end
   end
 
   # Reads a committed JSON fixture instead of the daemon.
   class FixtureClient < AgentsClient
-    def initialize(path, logs: nil, origins: {})
-      super()
+    def initialize(path, logs: nil, origins: {}, bridges: {})
+      super(jobs_dir: File.join(File.dirname(path), "jobs"))
       @path = path
       @logs = logs
       @origins = origins
+      @bridges = bridges
     end
 
     # Fixture rows carry no process tree; tag each interactive row from the
     # pid => origin map the test hands in, otherwise as a terminal, then drop
     # the unattended ones same as the real client does.
     def list
-      assign_origins(parse(File.read(@path)), @origins)
+      assign_origins(parse(File.read(@path)), @origins, @bridges)
     end
 
     def logs(_id) = @logs
@@ -219,6 +277,8 @@ module ClaudeInbox
       "deadbeef"
     end
 
+    def adopt(session_id:, cwd:, pid:) = "adop7ed0"
+
     def rm(_id) = true
   end
 end

data/lib/claude_inbox/app.rb

@@ -11,32 +11,38 @@ require_relative "terminal"
 require_relative "logs"
 require_relative "peek"
 require_relative "keymap"
+require_relative "remote"
 require_relative "mouse"
 require_relative "new_session_form"
 require_relative "paste"
 require_relative "pull_requests"
+require_relative "reaper"
 require_relative "poller"
 require_relative "rate_limits"
+require_relative "session_request"
 
 module ClaudeInbox
   # Owns the terminal and the key loop. The only class allowed to spawn a
   # child process that takes over the terminal.
   class App
-    # The reaper defaults to off. It is the only thing here that deletes a
-    # session, so switching it on is `bin/claude-inbox`'s job and nothing
-    # reaches it by forgetting an argument.
-    def initialize(client: AgentsClient.new, store: Store.new, pull_requests: PullRequests.new, jobs_dir: JobState::DEFAULT_DIR,
-      rate_limits: RateLimits.new, reaper: Reaper.disabled, out: $stdout, input: $stdin, color: true)
+    # The reaper deletes sessions and the listener lets other machines in,
+    # so both are off unless `bin/claude-inbox` switches them on.
+    def initialize(client: AgentsClient.new, store: Store.new, pull_requests: PullRequests.new,
+      rate_limits: RateLimits.new, reaper: Reaper.disabled, listen: nil, out: $stdout, input: $stdin, color: true,
+      terminal: Terminal.new(out, input), queue: Queue.new)
       @client = client
       @store = store
       @rate_limits = rate_limits
-      @terminal = Terminal.new(out, input)
+      @terminal = terminal
       @color = color
       @renderer = Renderer.new(color: color)
       @reader = TTY::Reader.new(input: input, output: out, interrupt: :noop)
-      @queue = Queue.new
-      @poller = Poller.new(client: client, store: store, pull_requests: pull_requests, jobs_dir: jobs_dir,
+      @queue = queue
+      @poller = Poller.new(client: client, store: store, pull_requests: pull_requests,
         reaper: reaper, queue: @queue)
+      @listener = listen ? Remote::Listener.new(client: client, store: store, queue: @queue, jobs_dir: client.jobs_dir, **listen) : Remote::Listener.disabled
+      @logs = Logs.new(client)
+      @peek = Peek.new(@logs)
       @selected = nil
       @row_items = []
       @list_width = nil
@@ -47,7 +53,6 @@ module ClaudeInbox
       @tick = 0
       @modal = nil
       @filter = nil
-      @status = "starting…"
       @last_poll = nil
       @quit = false
       @resize = false
@@ -58,13 +63,25 @@ module ClaudeInbox
       install_traps
       @terminal.enter
       @poller.start
-      @logs = Logs.new(@client)
-      @peek = Peek.new(@logs)
+      @listener.start
+      @logs.start
       main_loop
     ensure
       @poller.stop
-      @logs&.stop
+      @logs.stop
       @terminal.restore
+      @listener.stop
+    end
+
+    def step(input = nil)
+      drain_queue
+      @logs.tick
+      if @resize
+        @resize = false
+        @terminal.resized
+      end
+      render
+      handle_input(input) if input
     end
 
     private
@@ -99,6 +116,9 @@ module ClaudeInbox
         when :notice then notice(rest[0])
         when :select then @pending_select = rest[0]
         when :attach then attach(rest[0])
+        when :form_started then @modal = nil if @modal.equal?(rest[0])
+        when :form_failed then form_failed(*rest)
+        when :remote_started then remote_started(*rest)
         end
       end
     rescue ThreadError
@@ -108,17 +128,7 @@ module ClaudeInbox
     # ----- main loop --------------------------------------------------------
 
     def main_loop
-      until @quit
-        drain_queue
-        @logs.tick
-        if @resize
-          @resize = false
-          @terminal.resized
-        end
-        render
-        key = @reader.read_keypress(echo: false, raw: false, nonblock: true)
-        handle_input(key) if key
-      end
+      step(@reader.read_keypress(echo: false, raw: false, nonblock: true)) until @quit
     end
 
     def handle_input(raw)
@@ -131,10 +141,13 @@ module ClaudeInbox
     end
 
     # The form takes a paste whole, images included; the one-line editors
-    # take it as typing, so a pasted PR URL lands where it should.
+    # take it as typing, so a pasted PR URL lands where it should. Anywhere
+    # else a paste is dropped: typed out, its letters would be keys, and a
+    # "y" answers a confirm.
     def handle_paste(text)
       return @modal.paste(text) if @modal.is_a?(NewSessionForm)
-      text.each_char { |c| handle_key(c) }
+      typing = @modal ? @modal.is_a?(Dialog::Prompt) : @filter_editing
+      text.each_char { |c| handle_key(c) } if typing
     end
 
     def render
@@ -142,18 +155,16 @@ module ClaudeInbox
       now = Time.now
       sections = filtered(@store.sections(now))
       width, height = @terminal.size
+      body_h = Renderer.body_height(height)
       ensure_selection(sections)
-      peek = @peek.view(sections.row(@selected), height)
       @tick += 1
-      frame = @renderer.frame(
-        sections, width: width, height: height, now: now,
-        selected: @selected&.key, top: @top, expanded: @expanded,
-        peek: peek&.lines, peek_title: peek&.title, peek_subtitle: peek&.subtitle,
-        modal: modal_lines(width), screen: screen_lines(width, height), status: status_text(now), usage: @rate_limits.label(now),
-        filter: @filter, filter_editing: @filter_editing, tick: @tick / 2,
-        loading: loading_for
+      view = Renderer::View.new(
+        width: width, height: height, now: now, selected: @selected&.key, top: @top, expanded: @expanded,
+        peek: @peek.view(sections.row(@selected), body_h), modal: modal_lines(width), screen: screen_lines(width, body_h),
+        status: status_text(now), usage: @rate_limits.windows(now), filter: @filter, filter_editing: @filter_editing,
+        tick: @tick / 2, loading: loading_for, listening: @listener.snapshot
       )
-      @items = frame.items.compact
+      frame = @renderer.frame(sections, view)
       @row_items = frame.items
       @list_width = frame.list_width
       @top = frame.top
@@ -201,9 +212,10 @@ module ClaudeInbox
 
     # Guard for attach/stop: refuse politely on a terminal or remote row.
     def require_actionable
-      return true if selected_session&.actionable?
-      if (s = selected_session)&.interactive?
-        notice(s.remote? ? "that's a remote session — open it at claude.ai/code" : "that's your own terminal — switch to that window")
+      s = selected_session
+      return true if s&.actionable?
+      if s&.interactive?
+        notice(s.remote? ? "that's a remote session — Enter adopts it, w opens it at claude.ai/code" : "that's your own terminal — switch to that window")
       end
       false
     end
@@ -211,8 +223,9 @@ module ClaudeInbox
     # Guard for snooze/wake/alias: anything with a key, since those live in
     # our own store. A terminal you are sitting in is the one exception.
     def require_storable
-      return true if @selected&.row? && !selected_session&.terminal?
-      notice("you're in that terminal right now — nothing to snooze") if selected_session&.terminal?
+      s = selected_session
+      return true if @selected&.row? && !s&.terminal?
+      notice("you're in that terminal right now — nothing to snooze") if s&.terminal?
       false
     end
 
@@ -301,21 +314,23 @@ module ClaudeInbox
       when :alias then open_alias_editor
       when :link_pr then open_pr_editor
       when :open_pr then open_pr
+      when :open_remote then open_remote
       when :stop then open_confirm(:stop)
       when :delete then open_confirm(:delete)
       when :refresh then @poller.soon
       when :toggle_peek then toggle_peek
       when :new_session then open_new_session
+      when :remote_pairing then @modal = @listener.pairing_dialog
       when :filter then start_filter
       when :escape then clear_filter
       end
     end
 
-    def page = [@terminal.size[1] - 2, 1].max
+    def page = [Renderer.body_height(@terminal.size[1]), 1].max
 
     def move(delta)
-      return if @items.nil? || @items.empty?
       stops = filtered.selections(@expanded)
+      return if stops.empty?
       idx = stops.index(@selected) || 0
       select(stops[(idx + delta).clamp(0, stops.size - 1)])
     end
@@ -336,7 +351,8 @@ module ClaudeInbox
       name if Store::FOLDABLE_SECTIONS.include?(name)
     end
 
-    def set_expanded(value, name: current_fold_section)
+    def set_expanded(value)
+      name = current_fold_section
       @expanded[name] = value if name
     end
 
@@ -350,6 +366,7 @@ module ClaudeInbox
 
     def activate
       return @expanded[@selected.key] = true if @selected&.fold?
+      return @modal = Dialog::Confirm.new(:adopt, @selected.key) if selected_session&.remote?
       attach(@selected.key) if require_actionable
     end
 
@@ -404,25 +421,27 @@ module ClaudeInbox
       @modal = Dialog::Prompt.new(:pr, @selected.key, current)
     end
 
-    # Hands the first PR to the OS browser opener.
     def open_pr
       pr = selected_session&.pr
       return notice("no pull request linked — P sets one") unless pr
+      open_in_browser(pr.url, pr.short)
+    end
+
+    def open_remote
+      url = selected_session&.remote_url
+      return notice("no claude.ai/code page for this session") unless url
+      open_in_browser(url, "claude.ai/code")
+    end
+
+    def open_in_browser(url, what)
       opener = RUBY_PLATFORM.include?("darwin") ? "open" : "xdg-open"
-      notice("opening #{pr.short}")
-      in_background { Subprocess.capture(opener, pr.url) }
+      notice("opening #{what}")
+      in_background { Subprocess.capture(opener, url) }
     end
 
     def open_new_session
       cwd = selected_session&.cwd || Dir.pwd
-      @modal = NewSessionForm.new(cwd: strip_worktree(cwd), pastel: Pastel.new(enabled: @color))
-    end
-
-    # A session's cwd may sit inside a worktree another agent is using; carrying
-    # that into a new prompt would spawn the new agent there too, writing over
-    # the same files. Fall back to the repo the worktree was cut from.
-    def strip_worktree(cwd)
-      cwd.to_s.sub(%r{/\.claude/worktrees/[^/]+(?:/.*)?\z}, "")
+      @modal = NewSessionForm.new(cwd: SessionRequest.strip_worktree(cwd), pastel: Pastel.new(enabled: @color))
     end
 
     # `attach:` hands the terminal over as soon as the session starts. Without
@@ -434,15 +453,31 @@ module ClaudeInbox
       in_background do
         id = @client.spawn(**v)
         @queue << [:notice, "started #{id}"]
+        @queue << [:form_started, form]
         @queue << [:select, id]
         attach ? @queue << [:attach, id] : @poller.soon
+      rescue AgentsClient::Error => e
+        @queue << [:form_failed, form, e.message]
       end
     end
 
+    # Someone at the desk may be mid-thought, so a start from another
+    # device never moves the cursor, attaches or closes what is open.
+    def remote_started(id, via)
+      notice("started #{id} from #{via}")
+      @poller.soon
+    end
+
+    # A spawn failure hands the form back rather than just logging it, so
+    # the composed prompt survives (see NewSessionForm#submission_failed).
+    def form_failed(form, message)
+      @modal.equal?(form) ? form.submission_failed(message) : (@error = message)
+    end
+
     # The new-session form takes the whole body; a Dialog is a box over it.
-    def screen_lines(width, height)
+    def screen_lines(width, body_h)
       return nil unless @modal.is_a?(NewSessionForm)
-      {lines: @modal.screen(width, height - 2), footer: @modal.footer}
+      {lines: @modal.screen(width, body_h), footer: @modal.footer}
     end
 
     def modal_lines(width)
@@ -459,21 +494,26 @@ module ClaudeInbox
       when :confirm
         kind, id = @modal.kind, @modal.id
         @modal = nil
-        (kind == :stop) ? stop_session(id) : delete_session(id)
+        case kind
+        when :stop then stop_session(id)
+        when :delete then delete_session(id)
+        when :adopt then adopt_session(id)
+        end
       when :save then save_prompt
+      when :copy then @listener.copy_pairing_url
+      when :rotate then @listener.rotate
       end
     end
 
+    # `:start`/`:start_and_attach` leave the form as `@modal`, now busy: it
+    # closes itself once the spawn is confirmed to have started (`:form_started`)
+    # or reopens with the failure and the prompt intact (`:form_failed`).
     def handle_form_key(name, key)
       form = @modal
       case form.press(name, key)
       when :cancel then @modal = nil
-      when :start
-        @modal = nil
-        start_session(form, attach: false)
-      when :start_and_attach
-        @modal = nil
-        start_session(form, attach: true)
+      when :start then start_session(form, attach: false)
+      when :start_and_attach then start_session(form, attach: true)
       end
     end
 
@@ -484,6 +524,18 @@ module ClaudeInbox
       end
     end
 
+    def adopt_session(key)
+      s = session_for(key)
+      return unless s&.remote?
+      notice("adopting #{s.display_name}…")
+      in_background do
+        id = @client.adopt(session_id: s.session_id, cwd: s.cwd, pid: s.pid)
+        @queue << [:notice, "adopted as #{id}"]
+        @queue << [:select, id]
+        @queue << [:attach, id]
+      end
+    end
+
     def delete_session(id)
       notice("deleting #{id}…")
       in_background do

data/lib/claude_inbox/config.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+module ClaudeInbox
+  # Arguments for every launch. They go before the typed ones, so a typed
+  # flag wins.
+  module Config
+    PATH = File.join(Dir.home, ".config", "claude-inbox", "config")
+
+    def self.argv(typed, path: PATH)
+      args(path) + typed
+    end
+
+    def self.args(path)
+      File.readlines(path).flat_map { |line| Shellwords.split(line.sub(/(\A|\s)#.*/, "")) }
+    rescue Errno::ENOENT
+      []
+    rescue ArgumentError => e
+      raise ArgumentError, "#{path}: #{e.message}"
+    end
+    private_class_method :args
+  end
+end