claude-inbox 0.1.0 → 0.2.0

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>
@@ -72,16 +76,59 @@ module ClaudeInbox
     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)
+    # --remote-control takes an optional name and eats whatever follows it,
+    # prompt included, so it goes last.
+    def self.spawn_args(bin, prompt:, model: nil, effort: nil, permission_mode: nil, worktree: false, name: nil, remote: false)
       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"
       argv += ["--name", name] if name && !name.strip.empty?
       argv << "--worktree" if worktree
+      argv << "--remote-control" if remote
       argv
     end
 
+    # 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)
+      r = Subprocess.capture(*self.class.adopt_args(@bin, session_id), chdir: cwd)
+      raise Error, "claude --bg --resume failed: #{(r.err + r.out).strip}" unless r.success?
+      r.out[/\b[0-9a-f]{8}\b/] || r.out.strip
+    end
+
+    def self.adopt_args(bin, session_id) = [bin, "--bg", "--resume", session_id, "--remote-control"]
+
+    # 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
+
+    # 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
@@ -99,15 +146,17 @@ module ClaudeInbox
     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))
+      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 drops the unattended ones, whose
-    # parent is the row worth showing.
-    def assign_origins(sessions, origins)
+    # 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)) : s }
+        .map { |s| s.interactive? ? s.with(origin: origins.fetch(s.pid, :terminal), bridge_id: bridges[s.pid]) : s }
         .reject(&:unattended?)
     end
 
@@ -137,12 +186,16 @@ 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)
-      rows = ps_rows(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
+
+    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 +205,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.
@@ -192,18 +247,19 @@ module ClaudeInbox
 
   # 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 +275,8 @@ module ClaudeInbox
       "deadbeef"
     end
 
+    def adopt(session_id:, cwd:, pid:) = "adop7ed0"
+
     def rm(_id) = true
   end
 end

data/lib/claude_inbox/app.rb

@@ -25,18 +25,21 @@ module ClaudeInbox
     # 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)
+    def initialize(client: AgentsClient.new, store: Store.new, pull_requests: PullRequests.new,
+      rate_limits: RateLimits.new, reaper: Reaper.disabled, out: $stdout, input: $stdin, color: true,
+      terminal: Terminal.new(out, input))
       @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,
+      @poller = Poller.new(client: client, store: store, pull_requests: pull_requests,
         reaper: reaper, queue: @queue)
+      @logs = Logs.new(client)
+      @peek = Peek.new(@logs)
       @selected = nil
       @row_items = []
       @list_width = nil
@@ -47,7 +50,6 @@ module ClaudeInbox
       @tick = 0
       @modal = nil
       @filter = nil
-      @status = "starting…"
       @last_poll = nil
       @quit = false
       @resize = false
@@ -58,15 +60,25 @@ module ClaudeInbox
       install_traps
       @terminal.enter
       @poller.start
-      @logs = Logs.new(@client)
-      @peek = Peek.new(@logs)
+      @logs.start
       main_loop
     ensure
       @poller.stop
-      @logs&.stop
+      @logs.stop
       @terminal.restore
     end
 
+    def step(input = nil)
+      drain_queue
+      @logs.tick
+      if @resize
+        @resize = false
+        @terminal.resized
+      end
+      render
+      handle_input(input) if input
+    end
+
     private
 
     def install_traps
@@ -99,6 +111,8 @@ 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)
         end
       end
     rescue ThreadError
@@ -108,17 +122,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)
@@ -143,17 +147,14 @@ module ClaudeInbox
       sections = filtered(@store.sections(now))
       width, height = @terminal.size
       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), height), modal: modal_lines(width), screen: screen_lines(width, height),
+        status: status_text(now), usage: @rate_limits.windows(now), filter: @filter, filter_editing: @filter_editing,
+        tick: @tick / 2, loading: loading_for
       )
-      @items = frame.items.compact
+      frame = @renderer.frame(sections, view)
       @row_items = frame.items
       @list_width = frame.list_width
       @top = frame.top
@@ -203,7 +204,7 @@ module ClaudeInbox
     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")
+        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
@@ -301,6 +302,7 @@ 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
@@ -314,8 +316,8 @@ module ClaudeInbox
     def page = [@terminal.size[1] - 2, 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
@@ -350,6 +352,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,13 +407,22 @@ 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
@@ -434,11 +446,20 @@ 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
 
+    # 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)
       return nil unless @modal.is_a?(NewSessionForm)
@@ -459,21 +480,24 @@ 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
       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 +508,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/dialog.rb

@@ -49,10 +49,11 @@ module ClaudeInbox
       end
     end
 
-    # `X` stop and `Ctrl-x` delete both ask first and both take `y`, but the
-    # words differ because the outcomes do: read the box before answering.
+    # `X` stop, `Ctrl-x` delete and Enter on a remote row all ask first and
+    # all take `y`, but the words differ because the outcomes do: read the
+    # box before answering.
     class Confirm < Dialog
-      TITLES = {stop: " Stop ", delete: " Delete "}.freeze
+      TITLES = {stop: " Stop ", delete: " Delete ", adopt: " Adopt "}.freeze
 
       def title = TITLES.fetch(kind)
 
@@ -62,6 +63,9 @@ module ClaudeInbox
         when :delete
           ["  Delete session #{id}?", "  Its worktree and conversation", "  go with it.",
             "", "  y  delete it", "  esc  keep it"]
+        when :adopt
+          ["  Pull this session into the daemon?", "  Its phone session ends and a",
+            "  new one takes its place.", "", "  y  adopt it", "  esc  cancel"]
         end
       end
 

data/lib/claude_inbox/job_state.rb

@@ -13,8 +13,9 @@ module ClaudeInbox
   # each outstanding piece of work, and `detail` is the session's own status
   # line, with `needs` naming what it is waiting on while blocked and
   # `output.result` what it produced once done. It also carries the PR links the daemon scanned out of the
-  # transcript, which PullRequests reads through here, and the color `/color`
-  # set on the session, which `claude agents --json` drops.
+  # transcript, which PullRequests reads through here, the color `/color`
+  # set on the session, which `claude agents --json` drops, and `intent`, the
+  # prompt the session was started from.
   #
   # Never cached. A color changes the moment you type `/color`, so every poll
   # asks the file again.
@@ -49,7 +50,7 @@ module ClaudeInbox
       nil
     end
 
-    attr_reader :detail, :needs, :result, :tempo, :kinds, :tasks, :pr_urls, :color
+    attr_reader :detail, :needs, :result, :tempo, :kinds, :tasks, :pr_urls, :color, :intent, :bridge_id, :flags
 
     def initialize(hash)
       @detail = hash["detail"]
@@ -60,8 +61,15 @@ module ClaudeInbox
       @tasks = (hash["inFlight"] || {})["tasks"].to_i
       @pr_urls = (hash["children"] || []).select { |c| c["kind"] == "pr" && c["href"] }.map { |c| c["href"] }
       @color = hash["color"]
+      @intent = hash["intent"]
+      @bridge_id = hash["bridgeSessionId"]
+      @flags = hash["respawnFlags"] || []
     end
 
+    # The flags the session was started with, which the daemon puts back on
+    # a wake, are the only record of Remote Control being on it.
+    def remote_control? = flags.include?("--remote-control")
+
     # The agent itself is not thinking. On its own this means little — a
     # session whose process died leaves the same reading behind — so it only
     # says something paired with work still in flight.

data/lib/claude_inbox/keymap.rb

@@ -26,7 +26,7 @@ module ClaudeInbox
       "h" => :collapse,
       "s" => :snooze, "u" => :wake, "a" => :alias, "x" => :settle, "X" => :stop,
       :ctrl_x => :delete,
-      "o" => :open_pr, "P" => :link_pr, "t" => :toggle_pin,
+      "o" => :open_pr, "P" => :link_pr, "t" => :toggle_pin, "w" => :open_remote,
       "R" => :refresh, "p" => :toggle_peek, "n" => :new_session,
       :tab => :next_section, :back_tab => :prev_section,
       "/" => :filter, :escape => :escape,

data/lib/claude_inbox/logs.rb

@@ -18,8 +18,11 @@ module ClaudeInbox
       @pending = nil
       @pending_at = nil
       @requests = Queue.new
+    end
+
+    def start
+      return if @thread&.alive?
       @thread = Thread.new { worker }
-      @thread.abort_on_exception = false
     end
 
     def cached(id)
@@ -42,7 +45,7 @@ module ClaudeInbox
       @requests << id unless fresh
     end
 
-    def stop = @thread.kill
+    def stop = @thread&.kill
 
     private
 

data/lib/claude_inbox/new_session_form.rb

@@ -35,7 +35,8 @@ module ClaudeInbox
         Field.new(:model, "Model", :choice, DEFAULT, AgentsClient::MODELS),
         Field.new(:effort, "Effort", :choice, DEFAULT, AgentsClient::EFFORTS),
         Field.new(:permission_mode, "Permissions", :choice, DEFAULT, AgentsClient::PERMISSION_MODES),
-        Field.new(:worktree, "Worktree", :choice, "no", %w[no yes])
+        Field.new(:worktree, "Worktree", :choice, "no", %w[no yes]),
+        Field.new(:remote, "Remote Control", :choice, "no", %w[no yes])
       ]
       @focus = 0
       @error = nil
@@ -44,12 +45,19 @@ module ClaudeInbox
       @pick = 0
       @dismissed = nil
       @confirm_discard = false
+      @busy = false
     end
 
     def focused = @fields[@focus]
 
     # => :cancel | :start | :start_and_attach | :changed
     def press(name, raw)
+      # `:start`/`:start_and_attach` leave the form up until the spawn is
+      # known to have worked, so a failure (untrusted directory, `claude`
+      # missing, ...) can hand the composed prompt back instead of losing
+      # it; there is no way to cancel a spawn already under way, so every
+      # key is swallowed until the App reports back.
+      return :changed if @busy
       return confirm_discard_press(name, raw) if @confirm_discard
       @error = nil
       @candidates = nil
@@ -107,8 +115,9 @@ module ClaudeInbox
 
     def values
       @fields.to_h { |f| [f.key, f.value.to_s] }.tap do |v|
-        v[:prompt] = @fields[0].value.expand { |chip| AgentsClient.mention(chip.path) }.strip
+        v[:prompt] = field(:prompt).value.expand { |chip| AgentsClient.mention(chip.path) }.strip
         v[:worktree] = v[:worktree] == "yes"
+        v[:remote] = v[:remote] == "yes"
         v[:name] = nil if v[:name].strip.empty?
         v[:cwd] = File.expand_path(v[:cwd].strip.empty? ? "." : v[:cwd].strip)
       end
@@ -140,27 +149,23 @@ module ClaudeInbox
       menu_rows = menu_lines(inner_w, [height - fixed - 3, MENU_ROWS].min)
       prompt_h = [height - fixed - menu_rows.size, 3].max
       out = [""]
-      out << "  " + (@confirm_discard ? @theme.red("Discard this session? (y/n)") : @p.bold("New session"))
+      title = @busy ? @p.dim("Starting session…") : @p.bold("New session")
+      out << "  " + (@confirm_discard ? @theme.red("Discard this session? (y/n)") : title)
       out << ""
-      out << "  " + field_label(@fields[0]) + @p.dim("  ⏎ newline")
-      out += prompt_box(@fields[0], inner_w, prompt_h)
+      out << "  " + field_label(field(:prompt)) + @p.dim("  ⏎ newline")
+      out += prompt_box(field(:prompt), inner_w, prompt_h)
       out += menu_rows
       out << ""
-      @fields[1..].each { |f| out << "  " + field_label(f) + field_value(f, inner_w - 14) }
+      @fields[1..].each { |f| out << "  " + field_label(f) + field_value(f, inner_w - 16) }
       out.first(height) + [""] * [height - out.size, 0].max
     end
 
     def footer
-      if @confirm_discard
-        return [["y", "discard"], ["esc", "keep editing"]]
-            .map { |k, d| @theme.cyan_bold(k) + " " + @p.dim(d) }.join("  ")
-      end
+      return @p.dim("starting session…") if @busy
+      return hints([["y", "discard"], ["esc", "keep editing"]]) if @confirm_discard
       return @theme.red(@error) if @error
       return @p.dim("matches: ") + @candidates.join(@p.dim("  ")) if @candidates
-      if menu
-        return [["↑ ↓", "choose"], ["⇥ ⏎", "pick"], ["esc", "close"]]
-            .map { |k, d| @theme.cyan_bold(k) + " " + @p.dim(d) }.join("  ")
-      end
+      return hints([["↑ ↓", "choose"], ["⇥ ⏎", "pick"], ["esc", "close"]]) if menu
       keys =
         case focused.kind
         when :multiline then [["⏎", "newline"], ["^V", "image"]]
@@ -169,14 +174,24 @@ module ClaudeInbox
         end
       keys += [["^S", "start"], ["^O", "start & open"],
         ["⇥", (focused.key == :cwd) ? "complete / next" : "next"], ["esc", "cancel"]]
-      keys.map { |k, d| @theme.cyan_bold(k) + " " + @p.dim(d) }.join("  ")
+      hints(keys)
+    end
+
+    # The App's `claude --bg` call failed after `:start`/`:start_and_attach`
+    # already handed the form off — an untrusted directory, a stale binary,
+    # a permissions error. The composed prompt is still here, so the form
+    # reopens on it with the reason shown instead of the App just logging
+    # the failure and losing the draft.
+    def submission_failed(message)
+      @busy = false
+      @error = message
     end
 
     private
 
     # Esc with a prompt typed asks first, so a stray keypress can't lose it.
     def escape_pressed
-      return :cancel if @fields[0].value.empty?
+      return :cancel if field(:prompt).value.empty?
       @confirm_discard = true
       :changed
     end
@@ -242,9 +257,11 @@ module ClaudeInbox
       rows
     end
 
+    def hints(pairs) = pairs.map { |k, d| @theme.cyan_bold(k) + " " + @p.dim(d) }.join("  ")
+
     def field_label(f)
       on = f.equal?(focused)
-      (on ? @theme.cyan_bold("▶ ") : "  ") + (on ? @p.bold(Text.pad(f.label, 12)) : @p.dim(Text.pad(f.label, 12)))
+      (on ? @theme.cyan_bold("▶ ") : "  ") + (on ? @p.bold(Text.pad(f.label, 14)) : @p.dim(Text.pad(f.label, 14)))
     end
 
     # The cell the cursor sits on, drawn as a block by inverting it: a bar
@@ -325,6 +342,10 @@ module ClaudeInbox
 
     def move(d) = @focus = (@focus + d) % @fields.size
 
+    def field(key) = @fields.find { |f| f.key == key }
+
+    def focus_on(key) = @focus = @fields.index { |f| f.key == key }
+
     # Keys a :choice field answers to; an editable field spends these on its
     # own text instead.
     def choose(name, raw)
@@ -349,14 +370,15 @@ module ClaudeInbox
       v = values
       if v[:prompt].empty?
         @error = "a prompt is required"
-        @focus = 0
+        focus_on(:prompt)
         return :changed
       end
       unless File.directory?(v[:cwd])
         @error = "no such directory: #{v[:cwd]}"
-        @focus = 2
+        focus_on(:cwd)
         return :changed
       end
+      @busy = true
       attach ? :start_and_attach : :start
     end
   end

data/lib/claude_inbox/palette.rb

@@ -19,8 +19,6 @@ module ClaudeInbox
 
     RESET = "\e[39m"
 
-    def self.known?(name) = ANSI.key?(name) || INDEXED.key?(name)
-
     def self.sequence(name)
       return "\e[#{ANSI[name]}m" if ANSI.key?(name)
       return "\e[38;5;#{INDEXED[name]}m" if INDEXED.key?(name)

data/lib/claude_inbox/peek.rb

@@ -7,7 +7,7 @@ module ClaudeInbox
   # lands on a warm cache. Main-thread state only.
   class Peek
     TERMINAL_NOTE = "This is a claude you opened in a terminal yourself. The daemon can't attach to it, read its output, or stop it from outside. Switch to that window."
-    REMOTE_NOTE = "This is a Remote Control session driven from claude.ai/code. The daemon can't attach to it or read its output from here. Open it in the web or mobile app instead."
+    REMOTE_NOTE = "This is a Remote Control session driven from claude.ai/code. The daemon can't attach to it or read its output from here. Enter pulls it into the daemon; w opens it in the web or mobile app."
 
     # What Renderer paints: the body lines, the title bar, the dim line under it.
     View = Struct.new(:lines, :title, :subtitle)
@@ -58,7 +58,7 @@ module ClaudeInbox
     end
 
     def interactive_note(s)
-      [s.remote? ? REMOTE_NOTE : TERMINAL_NOTE, "", "pid #{s.pid} · #{s.cwd}", "session #{s.session_id}"]
+      [s.remote? ? REMOTE_NOTE : TERMINAL_NOTE, "", "pid #{s.pid} · #{s.cwd}", "session #{s.session_id}", s.remote_url].compact
     end
 
     def subtitle(row)