claude-inbox 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c29f6bef2ba7ecc7f4d63161cfc064517e21f95a3a187313a1c5b882ae34786
-  data.tar.gz: 5195d163ef619f7f82a7224ca0a9b4dfe508fd23d8c1b3d87ab0a7b3b419cb28
+  metadata.gz: 150bc4c5ae639139680ad48d476e0628faa82e89e77e783fb1ac9b2ac34ab25f
+  data.tar.gz: c40bbe7c0a955ba01edc66014b3b2ff9d8b80eb70d3b6ea4a9345495a69af011
 SHA512:
-  metadata.gz: 9b051d9eeba2b19da5c9ced63f9dcd00030619cc4c7ac667f873da8db411ecf3c777352d2b373dfb7def00c9737c6d1ed0bc8edb0663b0a73d850c01e429d20d
-  data.tar.gz: cfe120a05f387965ba538ea48dbf726ad1bf379684b1515d213bead19d02803be8030b14abd938457671c6d80fe0d65ce1de1715632db8c304b768a5e6d46ae8
+  metadata.gz: 1168c17b14d49071580d1c8565eff838a8c5229e339de5cbbd3f90ed78274973cbe1b1b0f3d21b89c4734142029630a1cb9ea8b03932655d22d151a3447faaf8
+  data.tar.gz: 7a6fb8224d67ae2ff94136d9615bb1a5caf12b7430031c5d221fde12a46357aef6f7ffd223f2ab725fb15d3797458ddb7f6cd824d890a01b3b525c0dbc8e3f1b

data/README.md

@@ -3,6 +3,10 @@
 An inbox for Claude Code's background sessions. It lists what `claude agents`
 lists and adds snooze, settle, pinning and each session's pull request.
 
+Inspired by [T3 Code](https://github.com/pingdotgg/t3code)'s functionality and
+inbox-style UX, I wanted a better way to manage my Claude agents, so I built
+this.
+
 ![claude-inbox with one working session, one snoozed and the settled section folded](docs/screenshot.png)
 
 ## Install
@@ -33,8 +37,8 @@ a fullscreen terminal.
 
 `/inbox` opens it, `ctrl+x tab` focuses it and `esc` leaves. The keys are the
 ones below, with `ge` for `G`, `n` `p` for `Tab` `Shift+Tab`, and no `a`,
-`P`, `X`, `Ctrl-x`, `/` or `R`. `Enter` switches to the session when you
-attached through `claude-inbox`.
+`P`, `X`, `Ctrl-x`, `/` or `R`. `Enter`, or a click on a row, switches to the
+session when you attached through `claude-inbox`.
 
 It opens when a session starts. To stop that, set
 `pluginConfigs.inbox-pane.options.openOnStart` to `false` in
@@ -97,6 +101,9 @@ session and `Ctrl-O` starts it and attaches.
 Paste an image on macOS, or drop a file into the prompt, and refer to it as
 `[Image #1]`. Type `/` for a menu of your skills.
 
+Type in Directory to pick from recent and trusted directories; `Ctrl-U`
+lists them all.
+
 ## How sessions move
 
 A snoozed session wakes when its timer runs out, when you press `u`, or when
@@ -108,11 +115,10 @@ again.
 A session settles when you press `x` or when all its pull requests are merged
 or closed. A session without a pull request only settles by hand.
 
-The inbox deletes background sessions that have been idle for 14 days, with
-`claude rm`. Working, pinned and snoozed sessions are kept, and `claude rm`
-refuses a worktree with unpushed commits. Each deletion is logged to
-`~/.config/claude-inbox/reaped.log`. Set `CLAUDE_INBOX_NO_REAP=1` to turn it
-off.
+With `--reap`, the inbox deletes background sessions that have been idle for
+14 days, with `claude rm`. Working, pinned and snoozed sessions are kept, and
+`claude rm` refuses a worktree with unpushed commits. Each deletion is logged
+to `~/.config/claude-inbox/reaped.log`.
 
 ## Remote Control
 

data/exe/claude-inbox

@@ -60,12 +60,13 @@ if 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. The listener,
-  # likewise, comes only from this file, and only when asked for.
+  # The only place the reaper is armed, and only with --reap: deleting
+  # sessions is opt-in. Everything else — tests, --fixture, 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[:reaper] = argv.include?("--reap") ? ClaudeInbox::Reaper.new(opts[:client], opts[:store]) : ClaudeInbox::Reaper.disabled
   opts[:snapshot] = ClaudeInbox::Snapshot.new
   opts[:switch] = ClaudeInbox::Switch.new
   opts[:actions] = ClaudeInbox::Actions.new

data/lib/claude_inbox/actions.rb

@@ -25,16 +25,16 @@ module ClaudeInbox
       @sent = 0
     end
 
-    # Leaves one request for the writer, as the pane does; `from` names the
-    # asker, and a count keeps two requests in one millisecond apart.
-    def request(action, id, choice: nil, from: "inbox-#{Process.pid}")
+    # Leaves one request for the writer, as the pane does, named for this
+    # inbox; a count keeps two requests in one millisecond apart.
+    def request(action, id, choice: nil)
       return unless @dir
       FileUtils.mkdir_p(@dir)
       at = (@clock.call.to_f * 1000).to_i
       request = {"action" => action, "id" => id, "at" => at}
       request["choice"] = choice if choice
       @sent += 1
-      File.write(File.join(@dir, "#{from}-#{at}-#{@sent}.json"), JSON.generate(request))
+      File.write(File.join(@dir, "inbox-#{Process.pid}-#{at}-#{@sent}.json"), JSON.generate(request))
     end
 
     # Applies every request on disk to `store` and returns how many it took.

data/lib/claude_inbox/agents_client.rb

@@ -39,6 +39,8 @@ module ClaudeInbox
 
     # Hands the terminal to the child; caller must have restored cooked mode.
     # Returns when the user detaches. Detaching never stops the session.
+    # False when the attach failed on its own, as a session that cannot be
+    # woken does: the CLI prints why and exits 1.
     #
     # Pressing ← inside an attached session detaches it and then `claude
     # attach` execs itself in place as `claude agents` (same pid). There is
@@ -52,7 +54,7 @@ module ClaudeInbox
       pid = Process.spawn(*Subprocess.command(@bin, "attach", id))
       watchdog = Thread.new { kill_when_agents_view(pid, &stop) }
       _, status = Process.wait2(pid)
-      status
+      status.success? || !status.exited?
     ensure
       watchdog&.kill
     end
@@ -188,14 +190,13 @@ module ClaudeInbox
     # 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 = {})
+    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))
     end
 

data/lib/claude_inbox/app.rb

@@ -11,7 +11,7 @@ require_relative "terminal"
 require_relative "logs"
 require_relative "peek"
 require_relative "keymap"
-require_relative "remote"
+require_relative "remote/listener"
 require_relative "mouse"
 require_relative "new_session_form"
 require_relative "paste"
@@ -23,6 +23,7 @@ require_relative "session_request"
 require_relative "actions"
 require_relative "snapshot"
 require_relative "switch"
+require_relative "trust"
 
 module ClaudeInbox
   # Owns the terminal and the key loop. The only class allowed to spawn a
@@ -32,7 +33,7 @@ module ClaudeInbox
     # 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, snapshot: Snapshot.disabled, switch: Switch.disabled,
-      actions: Actions.disabled, listen: nil, out: $stdout, input: $stdin, color: true,
+      actions: Actions.disabled, listen: nil, out: $stdout, input: $stdin, color: true, trust: Trust.method(:projects),
       terminal: Terminal.new(out, input), queue: Queue.new)
       @client = client
       @store = store
@@ -41,6 +42,7 @@ module ClaudeInbox
       @rate_limits = rate_limits
       @terminal = terminal
       @color = color
+      @trust = trust
       @renderer = Renderer.new(color: color)
       @input = input
       @reader = TTY::Reader.new(input: input, output: out, interrupt: :noop)
@@ -305,7 +307,7 @@ module ClaudeInbox
       return if @list_width && col > @list_width
       item = row_item_at(row)
       return unless item
-      select(item.selection)
+      select(item)
       activate
     end
 
@@ -313,7 +315,7 @@ module ClaudeInbox
     # no item of its own; a click there resolves to the row above it.
     def row_item_at(row)
       idx = row - 1
-      @row_items[idx] || (@row_items[idx - 1] if idx > 0 && @row_items[idx - 1]&.kind == :row)
+      @row_items[idx] || (@row_items[idx - 1] if idx > 0 && @row_items[idx - 1]&.row?)
     end
 
     def perform(action)
@@ -420,13 +422,16 @@ module ClaudeInbox
 
     # The pane in the attached session may ask for a different one: the
     # attach ends and the next starts without passing through the list. The
-    # poller keeps running meanwhile, so the pane's snapshot stays fresh.
+    # poller keeps running meanwhile, so the pane's snapshot stays fresh. A
+    # failed attach leaves its reason on screen until a key is pressed.
     def attach(id)
       while id
         @store.acknowledge(id)
         @switch.clear
-        from = @store.sessions.find { |s| s.key == id }&.session_id
-        @terminal.release { @client.attach(id) { @switch.requested_for?(from) } }
+        from = session_for(id)&.session_id
+        @terminal.release do
+          @terminal.pause unless @client.attach(id) { @switch.requested_for?(from) }
+        end
         id = @switch.take(@store.sessions.select(&:actionable?).map(&:key))
       end
     end
@@ -475,7 +480,8 @@ module ClaudeInbox
 
     def open_new_session
       cwd = selected_session&.cwd || Dir.pwd
-      @modal = NewSessionForm.new(cwd: SessionRequest.strip_worktree(cwd), pastel: Pastel.new(enabled: @color))
+      dirs = SessionRequest.directories(@store.sessions, @trust.call)
+      @modal = NewSessionForm.new(cwd: SessionRequest.strip_worktree(cwd), color: @color, dirs: dirs)
     end
 
     # `attach:` hands the terminal over as soon as the session starts. Without

data/lib/claude_inbox/headless.rb

@@ -13,12 +13,11 @@ module ClaudeInbox
   # reaps, since deleting sessions stays with the inbox you can see, and it
   # exits at once while an inbox holds the writer lock.
   class Headless
-    def initialize(client:, store:, pull_requests: PullRequests.new, snapshot: Snapshot.new, actions: Actions.new,
-      lock: WriterLock.new, queue: Queue.new)
+    def initialize(client:, store:, lock: WriterLock.new)
       @lock = lock
-      @queue = queue
-      @poller = Poller.new(client: client, store: store, pull_requests: pull_requests, reaper: Reaper.disabled,
-        queue: queue, snapshot: snapshot, actions: actions)
+      @queue = Queue.new
+      @poller = Poller.new(client: client, store: store, pull_requests: PullRequests.new, reaper: Reaper.disabled,
+        queue: @queue, snapshot: Snapshot.new, actions: Actions.new)
     end
 
     # False when the lock is held, by an inbox or another headless process.

data/lib/claude_inbox/new_session_form.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pastel"
 require_relative "agents_client"
 require_relative "images"
 require_relative "session_request"
@@ -18,6 +19,12 @@ module ClaudeInbox
     # string on :choice ones — `kind` says which.
     Field = Struct.new(:key, :label, :kind, :value, :choices)
 
+    # A directory the Directory field offers, shown by its shortest
+    # distinct label as the phone's form shows it.
+    Place = Struct.new(:path, :label, :description) do
+      def to_s = label
+    end
+
     # The screen shows what "default" resolves to; `values` makes it nil.
     DEFAULT = "default"
 
@@ -27,11 +34,13 @@ module ClaudeInbox
     # editable field spends these on its own text instead.
     CYCLE = {:left => -1, :right => 1, "h" => -1, "l" => 1, " " => 1}.freeze
 
-    def initialize(cwd:, pastel:, home: Dir.home, clipboard: Images.method(:from_clipboard))
-      @p = pastel
-      @theme = Theme.new(enabled: pastel.enabled)
+    def initialize(cwd:, color:, dirs: [], home: Dir.home, clipboard: Images.method(:from_clipboard))
+      @p = Pastel.new(enabled: color)
+      @theme = Theme.new(enabled: color)
       @home = home
       @clipboard = clipboard
+      @places = dirs.map { |path| Place.new(path, SessionRequest.label(path, dirs), path.sub(/\A#{Regexp.escape(home)}(?=\/|\z)/, "~")) }
+      @dir_settled = cwd.to_s
       @fields = [
         Field.new(:prompt, "Prompt", :multiline, TextBuffer.new),
         Field.new(:name, "Name", :text, TextBuffer.new),
@@ -66,7 +75,7 @@ module ClaudeInbox
       @error = nil
       @candidates = nil
       return :changed if menu && menu_press(name)
-      before = command_query
+      before = menu_query
       case name
       when :escape then return escape_pressed
       when :ctrl_s then return submit(attach: false)
@@ -80,7 +89,7 @@ module ClaudeInbox
       else
         editable? ? focused.value.press(name, raw) : choose(name, raw)
       end
-      edited = before && command_query && command_query != before
+      edited = before && menu_query && menu_query != before
       @pick = 0 if edited
       @dismissed = nil if edited
       :changed
@@ -103,10 +112,12 @@ module ClaudeInbox
       :changed
     end
 
+    # Slash commands while one is being typed in the prompt; the recent and
+    # trusted directories once the Directory field is edited.
     def menu
-      q = command_query
+      q = menu_query
       return nil if q.nil? || @dismissed == q
-      found = SlashCommands.match(commands, q)
+      found = (focused.key == :cwd) ? places(q) : SlashCommands.match(commands, q)
       found.empty? ? nil : found
     end
 
@@ -144,9 +155,12 @@ module ClaudeInbox
       out << ""
       out << "  " + field_label(field(:prompt)) + @p.dim("  ⏎ newline")
       out += prompt_box(field(:prompt), inner_w, prompt_h)
-      out += menu_rows
+      out += menu_rows if focused.key == :prompt
       out << ""
-      @fields[1..].each { |f| out << "  " + field_label(f) + field_value(f, inner_w - 16) }
+      @fields[1..].each do |f|
+        out << "  " + field_label(f) + field_value(f, inner_w - 16)
+        out += menu_rows if f.key == :cwd && focused.key == :cwd
+      end
       out.first(height) + [""] * [height - out.size, 0].max
     end
 
@@ -162,6 +176,7 @@ module ClaudeInbox
         when :choice then [["← → h l", "change"], ["⏎", "next"]]
         else [["⏎", "next"]]
         end
+      keys.unshift(["^U", "recent"]) if focused.key == :cwd && @places.any?
       keys += [["^S", "start"], ["^O", "start & open"],
         ["⇥", (focused.key == :cwd) ? "complete / next" : "next"], ["esc", "cancel"]]
       hints(keys)
@@ -179,9 +194,25 @@ module ClaudeInbox
 
     private
 
-    def command_query
-      return nil unless focused.key == :prompt
-      focused.value.head[/(?:\A|\s)\/(\S*)\z/, 1]
+    def menu_query
+      case focused.key
+      when :prompt then focused.value.head[/(?:\A|\s)\/(\S*)\z/, 1]
+      when :cwd then focused.value.to_s unless focused.value.to_s == @dir_settled
+      end
+    end
+
+    def places(query)
+      q = query.downcase
+      found = @places.select { |d| d.path.downcase.include?(q) || d.description.downcase.include?(q) }
+      starts, rest = found.partition { |d| d.label.downcase.start_with?(q) }
+      starts + rest
+    end
+
+    # A path put in the field by a pick or a completion rather than typed,
+    # so the menu stays shut until the next edit.
+    def settle_dir(path)
+      field(:cwd).value.replace(path)
+      @dir_settled = path
     end
 
     # Project commands live under the Directory field's path, so they
@@ -228,14 +259,18 @@ module ClaudeInbox
       when :up, :ctrl_p then @pick = (@pick - 1) % menu.size
       when :down, :ctrl_n then @pick = (@pick + 1) % menu.size
       when :tab, :return, :enter then accept(picked)
-      when :escape then @dismissed = command_query
+      when :escape then @dismissed = menu_query
       else return false
       end
       true
     end
 
-    def accept(cmd)
-      focused.value.replace_before(command_query.grapheme_clusters.size + 1, "#{cmd} ")
+    def accept(item)
+      if focused.key == :cwd
+        settle_dir(item.path)
+      else
+        focused.value.replace_before(menu_query.grapheme_clusters.size + 1, "#{item} ")
+      end
       @pick = 0
     end
 
@@ -327,10 +362,10 @@ module ClaudeInbox
       matches = Dir.glob(listing ? "#{base}/*" : "#{base}*").select { |d| File.directory?(d) }.sort
       return nil if matches.empty?
       if matches.size == 1
-        focused.value.replace("#{matches.first}/")
+        settle_dir("#{matches.first}/")
       else
         @candidates = matches.map { |d| File.basename(d) }
-        focused.value.replace(common_prefix(matches))
+        settle_dir(common_prefix(matches))
       end
       :changed
     end

data/lib/claude_inbox/painter.rb

@@ -18,9 +18,7 @@ module ClaudeInbox
         next if @prev[i] == line
         buf << TTY::Cursor.move_to(0, i) << line
       end
-      if @prev.size > lines.size
-        (lines.size...@prev.size).each { |i| buf << TTY::Cursor.move_to(0, i) << TTY::Cursor.clear_line }
-      end
+      (lines.size...@prev.size).each { |i| buf << TTY::Cursor.move_to(0, i) << TTY::Cursor.clear_line }
       @out.print buf unless buf.empty?
       @out.flush
       @prev = lines

data/lib/claude_inbox/poller.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "actions"
 require_relative "sessions"
-require_relative "snapshot"
 
 module ClaudeInbox
   # Asks `claude agents` for the list off the main thread, every INTERVAL
@@ -17,7 +15,7 @@ module ClaudeInbox
     INTERVAL = 4
     ACTIONS_INTERVAL = 0.5
 
-    def initialize(client:, store:, pull_requests:, reaper:, queue:, snapshot: Snapshot.disabled, actions: Actions.disabled,
+    def initialize(client:, store:, pull_requests:, reaper:, queue:, snapshot:, actions:,
       interval: INTERVAL, clock: -> { Time.now })
       @client = client
       @clock = clock

data/lib/claude_inbox/pull_requests.rb

@@ -76,7 +76,7 @@ module ClaudeInbox
     # one (interactive, or forgotten) has none; Sessions.load sees to the
     # order. `overrides` maps session key => url for links set by hand; an
     # override replaces the scanned list.
-    def enrich(sessions, overrides = {})
+    def enrich(sessions, overrides)
       sessions.map do |s|
         urls = overrides[s.key] ? [overrides[s.key]] : (s.job_state&.pr_urls || [])
         s.with(prs: urls.map { |u| known(u) })

data/lib/claude_inbox/rate_limits.rb

@@ -30,7 +30,7 @@ module ClaudeInbox
     # time, or nil.
     # Parses only when the file has changed, since render asks several times
     # a second.
-    def windows(now = Time.now)
+    def windows(now)
       mtime = File.mtime(@path)
       return nil if now - mtime > STALE_AFTER
       @data = parse if mtime != @mtime

data/lib/claude_inbox/reaper.rb

@@ -20,15 +20,13 @@ module ClaudeInbox
     RETRY_AFTER = 24 * 3600
     DEFAULT_LOG = File.join(Dir.home, ".config", "claude-inbox", "reaped.log")
 
-    def initialize(client, store, log_path: DEFAULT_LOG, enabled: self.class.enabled?)
+    def initialize(client, store, log_path: DEFAULT_LOG, enabled: true)
       @client = client
       @store = store
       @log_path = log_path
       @enabled = enabled
     end
 
-    def self.enabled? = ENV["CLAUDE_INBOX_NO_REAP"].to_s.empty?
-
     # For --fixture runs and tests: selects nothing, deletes nothing, and
     # needs neither a client nor a store to do it.
     def self.disabled = new(nil, nil, enabled: false)

data/lib/claude_inbox/remote/http.rb

@@ -107,7 +107,7 @@ module ClaudeInbox
         end
       end
 
-      def self.write(io, status, headers = {}, body = "")
+      def self.write(io, status, headers, body)
         body = body.b
         head = ["HTTP/1.1 #{status} #{REASONS.fetch(status)}"]
         HEADERS.merge(headers, "Content-Length" => body.bytesize.to_s).each { |name, value| head << "#{name}: #{value}" }

data/lib/claude_inbox/remote/listener.rb

@@ -17,7 +17,7 @@ module ClaudeInbox
     # connection limits, the static files and the Pairing token, in front of
     # Start. Like the Poller it reaches App only through the queue, and it
     # never writes to the terminal: every failure becomes a response or a
-    # notice.
+    # notice. It is App's only way into Remote.
     class Listener
       DEFAULT_PORT = 7433
       DEFAULT_MODES = %w[default auto plan].freeze
@@ -58,17 +58,13 @@ module ClaudeInbox
       # lock, as `held_by`) or :failed (for good, as `error` says). `urls` and
       # `firewall` are nil until `refresh`.
       Snapshot = Data.define(:state, :port, :lan, :urls, :firewall, :allowed_modes, :recent, :held_by, :fixture, :error) do
-        def initialize(error: nil, **) = super
-
         # Over a VPN only an address reaches the Mac: multicast DNS, which
         # the .local name needs, stays on the LAN.
         def pairing_url = (lan && urls&.[](1)) || urls&.first
       end
 
       # `count` is how many times `via` got `result`, the last at `at`.
-      Outcome = Data.define(:at, :via, :result, :count) do
-        def initialize(at:, via:, result:, count: 1) = super
-      end
+      Outcome = Data.define(:at, :via, :result, :count)
 
       # App's `listen:` from the flags, else the environment; nil when neither
       # asks for it. --listen-lan wins over --listen, whichever came last.

data/lib/claude_inbox/remote/start.rb

@@ -26,7 +26,7 @@ module ClaudeInbox
       BODY_TIMEOUT = 120
       KEYS_KEPT = 16
 
-      def initialize(client:, store:, queue:, allowed_modes:, fixture: false, images_dir: Images::DEFAULT_DIR,
+      def initialize(client:, store:, queue:, allowed_modes:, fixture:, images_dir: Images::DEFAULT_DIR,
         trust: Trust.method(:projects), settings: Settings.method(:defaults), bridge_wait: 3)
         @client = client
         @store = store
@@ -62,13 +62,7 @@ module ClaudeInbox
         }
       end
 
-      # Where sessions ran lately, newest first, then every directory whose
-      # trust dialog was accepted: the likely choices first. Only an order;
-      # the CLI still decides where a session may start.
-      def dir_paths
-        recent = @store.sessions.sort_by { |s| -s.started_at.to_i }.filter_map { |s| s.cwd && SessionRequest.strip_worktree(s.cwd) }
-        (recent + @trust.call).uniq.select { |dir| File.directory?(dir) }
-      end
+      def dir_paths = SessionRequest.directories(@store.sessions, @trust.call)
 
       # Checked cheapest first, and nothing is written to disk until every
       # check has passed. A retry with the same Idempotency-Key gets the

data/lib/claude_inbox/renderer.rb

@@ -11,12 +11,6 @@ module ClaudeInbox
   # `width` columns wide) plus a parallel Array of selectable items.
   # Pure: no terminal, no IO, no clock beyond the `now` it is handed.
   class Renderer
-    Item = Struct.new(:kind, :row, :section) do
-      def selection = (kind == :fold_toggle) ? Store::Selection.fold(section) : Store::Selection.row(row.key)
-
-      def key = selection.key
-    end
-
     Frame = Struct.new(:lines, :items, :top, :list_width)
 
     CHROME_ROWS = 2 # header + footer
@@ -175,7 +169,7 @@ module ClaudeInbox
       end
     end
 
-    def header_chips(sections, compact:, listening: nil)
+    def header_chips(sections, compact:, listening:)
       pinned = sections.pinned.size
       needing = sections.needs_you.size
       working = sections.active.count { |r| r.session.effective_state == "working" && !r.session.waiting_on_work? }
@@ -214,7 +208,7 @@ module ClaudeInbox
 
     def footer(width, view)
       text =
-        if view.filter_editing then " " + @theme.cyan_bold("/") + line(view.filter, width - 2)
+        if view.filter_editing then " " + @theme.cyan_bold("/") + view.filter.row(width - 2, cursor: caret)
         elsif view.filter then " " + @theme.cyan_bold("/") + view.filter.to_s + @p.dim("  esc clears")
         else " " + footer_keys(view).map { |k, d| @theme.cyan_bold(k) + " " + @p.dim(d) }.join("  ")
         end
@@ -226,8 +220,6 @@ module ClaudeInbox
       KEYS.flat_map { |key| (key[0] == "n") ? [key, ["N", "pair"]] : [key] }
     end
 
-    def line(buffer, width) = buffer.row(width, cursor: caret)
-
     def section_title(name, count, width)
       title = " #{SECTION_TITLES[name]} "
       count_s = " #{count} "
@@ -256,13 +248,13 @@ module ClaudeInbox
         items << nil << nil
         if Store.folded?(name, view.expanded)
           lines << fold_toggle_line(name, rows.size, selected, width)
-          items << Item.new(:fold_toggle, nil, name)
+          items << Store::Selection.fold(name)
           next
         end
         rows.each do |row|
           row_lines(row, name, selected, width, view.now, view.tick).each_with_index do |l, i|
             lines << l
-            items << ((i.zero? && row.selectable?) ? Item.new(:row, row, name) : nil)
+            items << ((i.zero? && row.selectable?) ? Store::Selection.row(row.key) : nil)
           end
         end
       end

data/lib/claude_inbox/session_request.rb

@@ -80,6 +80,16 @@ module ClaudeInbox
     # writing over the same files. Fall back to the repo it was cut from.
     def self.strip_worktree(cwd) = cwd.to_s.sub(%r{/\.claude/worktrees/[^/]+(?:/.*)?\z}, "")
 
+    # Where sessions ran lately, newest first, then every directory whose
+    # trust dialog was accepted: the likely choices first. Only an order;
+    # the CLI still decides where a session may start. Every worktree gets
+    # trusted on its own, so each folds into its repo rather than crowding
+    # the list.
+    def self.directories(sessions, trusted)
+      recent = sessions.sort_by { |s| -s.started_at.to_i }.filter_map(&:cwd)
+      (recent + trusted).map { |dir| strip_worktree(dir) }.uniq.select { |dir| File.directory?(dir) }
+    end
+
     # The daemon's summary line can echo the prompt to the terminal, so no
     # control character but tab and newline gets that far. A CRLF, the
     # newline an HTTP client may send, is taken as a newline.

data/lib/claude_inbox/slash_commands.rb

@@ -13,7 +13,7 @@ module ClaudeInbox
   #
   # Pure: filesystem in, plain values out. Nothing here runs `claude`.
   module SlashCommands
-    Command = Struct.new(:name, :description, :source) do
+    Command = Struct.new(:name, :description) do
       def to_s = "/#{name}"
     end
 
@@ -26,8 +26,8 @@ module ClaudeInbox
     def list(cwd:, home: Dir.home)
       found = {}
       add = ->(cmd) { found[cmd.name] ||= cmd }
-      from_dir(File.join(cwd, ".claude"), "project").each(&add)
-      from_dir(File.join(home, ".claude"), "user").each(&add)
+      from_dir(File.join(cwd, ".claude")).each(&add)
+      from_dir(File.join(home, ".claude")).each(&add)
       plugins(home).each(&add)
       synced(home).each(&add)
       found.values.sort_by(&:name)
@@ -39,25 +39,25 @@ module ClaudeInbox
       starts + rest.select { |c| c.name.downcase.include?(q) }
     end
 
-    def from_dir(dir, source, prefix: nil)
-      skills(File.join(dir, "skills"), source, prefix:) +
-        commands(File.join(dir, "commands"), source, prefix:)
+    def from_dir(dir, prefix: nil)
+      skills(File.join(dir, "skills"), prefix:) +
+        commands(File.join(dir, "commands"), prefix:)
     end
 
-    def skills(dir, source, prefix: nil)
+    def skills(dir, prefix: nil)
       Dir.glob(File.join(dir, "*", "SKILL.md")).sort.filter_map do |path|
         meta = frontmatter(path)
         next if meta["user-invocable"] == "false"
         name = File.basename(File.dirname(path))
-        Command.new(qualify(prefix, name), meta["description"].to_s, source)
+        Command.new(qualify(prefix, name), meta["description"].to_s)
       end
     end
 
     # A command file's name is its own; a subdirectory only groups them.
-    def commands(dir, source, prefix: nil)
+    def commands(dir, prefix: nil)
       Dir.glob(File.join(dir, "**", "*.md")).sort.map do |path|
         name = File.basename(path, ".md")
-        Command.new(qualify(prefix, name), frontmatter(path)["description"].to_s, source)
+        Command.new(qualify(prefix, name), frontmatter(path)["description"].to_s)
       end
     end
 
@@ -71,7 +71,7 @@ module ClaudeInbox
       (installed["plugins"] || {}).flat_map do |key, entries|
         plugin = key.split("@").first
         Array(entries).filter_map { |e| e["installPath"] if e.is_a?(Hash) }.uniq.flat_map do |root|
-          from_dir(root, "plugin", prefix: plugin)
+          from_dir(root, prefix: plugin)
         end
       end
     end
@@ -80,7 +80,7 @@ module ClaudeInbox
     # ~/.claude/skills/synced and answer to the anthropic-skills prefix.
     def synced(home)
       Dir.glob(File.join(home, ".claude", "skills", "synced", "*", "")).flat_map do |bucket|
-        skills(bucket, "synced", prefix: SYNCED_PLUGIN)
+        skills(bucket, prefix: SYNCED_PLUGIN)
       end
     end
 

data/lib/claude_inbox/snapshot.rb

@@ -23,7 +23,7 @@ module ClaudeInbox
     # Called from the poller's threads and the screen's alike.
     def write(sections, now)
       return unless @path
-      body = sections.to_h.to_h { |name, rows| [name.to_s, rows.map { |row| row_hash(row) }] }
+      body = sections.to_h { |name, rows| [name.to_s, rows.map { |row| row_hash(row) }] }
       @mutex.synchronize do
         return if body == @body && now.to_i - @written_at < HEARTBEAT
         @body = body
@@ -39,8 +39,7 @@ module ClaudeInbox
       pr = s.pr
       {
         "id" => row.key, "session" => s.session_id, "label" => row.label, "state" => s.effective_state, "actionable" => s.actionable?,
-        "waiting" => s.waiting_on_work? || nil, "terminal" => s.terminal? || nil,
-        "cwd" => s.cwd, "line" => s.summary, "wake_at" => row.wake_at, "remote" => s.remote_url,
+        "waiting" => s.waiting_on_work? || nil, "line" => s.summary, "wake_at" => row.wake_at, "remote" => s.remote_url,
         "pr" => pr && {"short" => pr.short, "state" => pr.state&.downcase, "url" => pr.url}
       }.compact
     end

data/lib/claude_inbox/store/row.rb

@@ -5,8 +5,6 @@ module ClaudeInbox
     # A session paired with its Entry (nil until a poll has recorded one), with
     # the triage rules as its methods; each takes `now`, so a Row is pure.
     Row = Struct.new(:session, :entry) do
-      def id = session.id
-
       def key = session.key
 
       def selectable? = !key.nil?

data/lib/claude_inbox/switch.rb

@@ -16,11 +16,9 @@ module ClaudeInbox
       @path = path
     end
 
-    def request(id, from, now) = @path && Records.save(@path, {"id" => id, "from" => from, "at" => now.to_i})
-
     # Whether the session `from` has asked to go elsewhere.
     def requested_for?(from)
-      return false if @path.nil? || from.nil? || !File.exist?(@path)
+      return false if from.nil?
       Records.read(@path)["from"] == from
     end
 

data/lib/claude_inbox/terminal.rb

@@ -76,6 +76,14 @@ module ClaudeInbox
       enter
     end
 
+    # Inside `release`: keeps what a failed child printed on the screen
+    # until a key is pressed, since `enter` would cover it at once.
+    def pause
+      @out.print "\r\npress any key to return to claude-inbox"
+      @out.flush
+      @input.tty? ? @input.getch : @input.getc
+    end
+
     # [cols, rows]. Cached: querying the terminal can fall back to spawning
     # `tput`, which is far too slow to do on every frame. Refreshed by
     # `resized`, which WINCH and re-entry both call.

data/lib/claude_inbox/writer_lock.rb

@@ -37,13 +37,6 @@ module ClaudeInbox
       file.flock(File::LOCK_EX | File::LOCK_NB) ? hold(file, role) : refuse(file)
     end
 
-    def held? = !@file.nil?
-
-    def release
-      @file&.close
-      @file = nil
-    end
-
     private
 
     # After reading the holder the position sits at the end, and truncate does
@@ -53,7 +46,7 @@ module ClaudeInbox
       file.truncate(0)
       file.write("#{role} #{Process.pid}")
       file.flush
-      @file = file
+      @file = file # only kept so GC never closes it and drops the flock
       true
     end
 

data/lib/claude_inbox.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ClaudeInbox
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/mod/hooks/register.tsx

@@ -33,8 +33,6 @@ export type SnapshotRow = {
   state?: string
   actionable?: boolean
   waiting?: boolean
-  terminal?: boolean
-  cwd?: string
   line?: string
   wake_at?: number | 'until_woken'
   remote?: string
@@ -43,7 +41,7 @@ export type SnapshotRow = {
 type Snapshot = { written_at?: number; sections?: Partial<Record<Section, SnapshotRow[]>> }
 // This session, as the gem's files name it, and the headless inbox this module may start.
 type Host = { session: string; command: string; headlessStartedAt: number; isHeadlessRunning: boolean }
-type Fold = 'snoozed' | 'settled'
+type Fold = keyof Folds
 type Item = { kind: 'row'; row: InboxRow } | { kind: 'fold'; section: Fold; count: number }
 type Snooze = 'm15' | 'h1' | 'tomorrow_9am' | 'until_woken'
 type Action = { action: 'settle' | 'wake' | 'pin'; id: string } | { action: 'snooze'; id: string; choice: Snooze }
@@ -60,7 +58,7 @@ const SNOOZE: Record<string, { choice: Snooze; label: string }> = {
   '4': { choice: 'until_woken', label: 'until woken' },
 }
 // What each chord's second key does, drawn under the footer while it waits.
-const MENU: Record<'g' | 'z' | 's', [string, string][]> = {
+const MENU: Record<NonNullable<Pending>, [string, string][]> = {
   g: [
     ['g', 'first'],
     ['e', 'last'],
@@ -82,7 +80,7 @@ function isFold(section: Section): section is Fold {
   return section === 'snoozed' || section === 'settled'
 }
 
-// The hidden Button standing for an item: the ring walks these with the arrows.
+// The Button drawn for an item, its label: the ring walks these with the arrows, a click presses one.
 function itemKey(item: Item): string {
   return item.kind === 'fold' ? `fold:${item.section}` : `row:${item.row.id ?? item.row.label}`
 }
@@ -105,6 +103,15 @@ function groupsOf(list: InboxRow[], folded: Folds, current: InboxRow | null): {
   )
 }
 
+async function listed($: EngineInterface): Promise<Item[]> {
+  return groupsOf(await read($, rows), await read($, folds), await read($, current)).flatMap(group => group.items)
+}
+
+// The stored cursor may point past a list that has shrunk since it was set.
+function onList(flat: Item[], at: number): number {
+  return Math.min(at, Math.max(0, flat.length - 1))
+}
+
 async function readJson<T>($: EngineInterface, path: string, fallback: T): Promise<T> {
   try {
     return JSON.parse(await $.fs.read(path)) as T
@@ -123,8 +130,6 @@ export function rowOf(section: Section, one: SnapshotRow): InboxRow {
     state: one.state ?? 'unknown',
     actionable: one.actionable === true,
     isWaiting: one.waiting === true,
-    isTerminal: one.terminal === true,
-    cwd: one.cwd,
     line: one.line,
     wakeAt: one.wake_at,
     remote: one.remote,
@@ -142,26 +147,34 @@ function ago(seconds: number): string {
   return seconds < 60 ? 'just now' : `${Math.floor(seconds / 60)}m ago`
 }
 
+async function inboxFile($: EngineInterface, path: string): Promise<string> {
+  return `${(await $.env.get('HOME')) ?? ''}/${path}`
+}
+
 async function nowS($: EngineInterface): Promise<number> {
   return Math.floor((await $.clock.now()) / 1000)
 }
 
+// Read each time: it is the transcript's name, which the daemon reports as sessionId,
+// and a /clear may mint a new one mid-session.
+async function sessionId($: EngineInterface, host: Host): Promise<string> {
+  return $.session.id().catch(() => host.session)
+}
+
 // Leaves one request for the inbox to apply; its poller takes it within half a second
 // and the next snapshot shows the row where the gem's own rules put it.
 async function ask($: EngineInterface, host: Host, action: Action): Promise<void> {
-  const home = (await $.env.get('HOME')) ?? ''
+  const actions = await inboxFile($, ACTIONS)
   const at = Math.floor(await $.clock.now())
-  await $.fs.write(`${home}/${ACTIONS}/${host.session}-${at}.json`, JSON.stringify({ ...action, at }))
+  await $.fs.write(`${actions}/${host.session}-${at}.json`, JSON.stringify({ ...action, at }))
 }
 
 // Asks the inbox attached to this session for another one. It takes the file when it
 // does; a file still there after SWITCH_MS, and still ours, means no inbox is attached to
-// this session. The session id is read each time: it is the transcript's name, which the
-// daemon reports as sessionId, and a /clear may mint a new one mid-session.
+// this session.
 async function requestSwitch($: EngineInterface, host: Host, id: string): Promise<void> {
-  const home = (await $.env.get('HOME')) ?? ''
-  const path = `${home}/${SWITCH}`
-  const from = await $.session.id().catch(() => host.session)
+  const path = await inboxFile($, SWITCH)
+  const from = await sessionId($, host)
   const at = await nowS($)
   await $.fs.write(path, JSON.stringify({ id, from, at }))
   $.ui.toast(`switching to ${id}…`)
@@ -194,14 +207,13 @@ function startHeadless($: EngineInterface, host: Host, now: number): void {
 }
 
 async function poll($: EngineInterface, host: Host): Promise<void> {
-  const home = (await $.env.get('HOME')) ?? ''
+  const file = await inboxFile($, SNAPSHOT)
   const now = await nowS($)
-  const snapshot = await readJson<Snapshot | null>($, `${home}/${SNAPSHOT}`, null)
+  const snapshot = await readJson<Snapshot | null>($, file, null)
   const written = snapshot?.written_at ?? 0
   if (snapshot !== null) {
     const all = ORDER.flatMap(section => (snapshot.sections?.[section] ?? []).map(one => rowOf(section, one)))
-    // Read on every poll: a /clear mints a new session id mid-session.
-    const id = await $.session.id().catch(() => host.session)
+    const id = await sessionId($, host)
     await update($, current, () => all.find(one => one.session === id) ?? null)
     await update($, rows, () => all.filter(one => one.session !== id))
   }
@@ -209,7 +221,7 @@ async function poll($: EngineInterface, host: Host): Promise<void> {
   if (now - written > STALE_S) startHeadless($, host, now)
 }
 
-// Puts the ring on the item's hidden Button, so Enter acts on it, and scrolls it into view.
+// Puts the ring on the item's Button, so Enter acts on it, and scrolls it into view.
 async function ringOn($: EngineInterface, item: Item): Promise<void> {
   await $.ui.focus({ requestId: PANE, key: itemKey(item) }).catch(() => undefined)
   await $.ui.scroll({ in: PANE, to: { key: viewKey(item) }, block: 'nearest' }).catch(() => undefined)
@@ -227,7 +239,7 @@ async function moveTo($: EngineInterface, flat: Item[], to: number): Promise<voi
 async function setFold($: EngineInterface, list: InboxRow[], current: InboxRow | null, name: Fold | undefined, open: boolean): Promise<void> {
   await update($, pending, () => null)
   if (!name) return
-  const folded = await update($, folds, f => ({ ...(f ?? { snoozed: true, settled: true }), [name]: !open }))
+  const folded = await update($, folds, f => ({ ...f, [name]: !open }))
   // The item under the cursor may have just become a fold, or the fold its rows.
   const groups = groupsOf(list, folded, current)
   const at = groups.findIndex(group => group.section === name)
@@ -265,12 +277,12 @@ export const register: Register = (on, options) => {
     return { text: `Inbox pane open on ${surfaces}. ctrl+x tab focuses it; the keys are claude-inbox's.` }
   })
 
-  // The ring walks the items' hidden Buttons and nothing else: entering the pane it lands on
+  // The ring walks the items' Buttons and nothing else: entering the pane it lands on
   // the cursor's item, the arrows move it to the next, and the cursor follows.
   on('ui.focus', { requestId: PANE }, async ($, e, next) => {
-    const flat = groupsOf(await read($, rows), await read($, folds), await read($, current)).flatMap(group => group.items)
+    const flat = await listed($)
     if (e.element === undefined) {
-      const item = flat[Math.min(await read($, cursor), Math.max(0, flat.length - 1))]
+      const item = flat[onList(flat, await read($, cursor))]
       return item ? next({ ...e, element: itemKey(item) }) : next(e)
     }
     const at = flat.findIndex(item => itemKey(item) === e.element)
@@ -284,8 +296,8 @@ export const register: Register = (on, options) => {
   // moves the cursor instead, and the wheel, the page keys and the pane's own scrolls pass.
   on('ui.scroll', { requestId: PANE }, async ($, e, next) => {
     if (e.origin.kind !== 'person' || e.pointer !== undefined || Math.abs(e.by) !== 1) return next(e)
-    const flat = groupsOf(await read($, rows), await read($, folds), await read($, current)).flatMap(group => group.items)
-    const at = Math.min(await read($, cursor), Math.max(0, flat.length - 1))
+    const flat = await listed($)
+    const at = onList(flat, await read($, cursor))
     await moveTo($, flat, at + e.by)
     return {}
   })
@@ -300,7 +312,7 @@ export const register: Register = (on, options) => {
     const ageS = (await nowS($)) - written
     const groups = groupsOf(list, folded, viewing)
     const flat = groups.flatMap(group => group.items)
-    const at = Math.min(await read($, cursor), Math.max(0, flat.length - 1))
+    const at = onList(flat, await read($, cursor))
     const selected = flat[at]
     const row = selected?.kind === 'row' ? selected.row : undefined
     const section = selected?.kind === 'fold' ? selected.section : row === viewing ? undefined : row?.section
@@ -329,8 +341,10 @@ export const register: Register = (on, options) => {
       void ask($, host, { action, id: row.id }).then(() => $.ui.toast(`${verb} ${row.label}`))
     }
     const key = (hotkey: string, onPress: () => void) => <Button key={hotkey} hotkey={hotkey} plain label="" onPress={onPress} />
-    // Enter on an item: a fold opens, a row the inbox can attach to asks for the switch.
+    // Enter or a click on an item: the cursor lands on it, a fold opens, a row the inbox can
+    // attach to asks for the switch.
     const enter = (item: Item) => () => {
+      void moveTo($, flat, flat.indexOf(item))
       if (item.kind === 'fold') return void setFold($, list, viewing, item.section, true)
       if (item.row === viewing) return $.ui.toast('you are in this session')
       if (!item.row.id || !item.row.actionable) return $.ui.toast('this session cannot be attached')
@@ -383,8 +397,8 @@ export const register: Register = (on, options) => {
 
     return (
       <Box flexDirection="column">
-        {/* The header shares the pane's top row with the engine's close mark, which takes the last cells. */}
-        <Box columnGap={2} paddingRight={3}>
+        {/* The engine draws its close mark on a row of its own above the body, so the header can't share it. */}
+        <Box columnGap={2}>
           <Text color="cyan" bold>
             claude-inbox
           </Text>
@@ -408,7 +422,7 @@ export const register: Register = (on, options) => {
                 return (
                   <Box key={viewKey(item)}>
                     <Text color={isHere ? 'yellow' : undefined}>{isHere ? '› ' : '  '}</Text>
-                    <Text dimColor>▸ {item.count} folded · za opens</Text>
+                    <Button key={itemKey(item)} plain dimColor label={`▸ ${item.count} folded · za opens`} onPress={enter(item)} autoFocus={isHere || undefined} />
                   </Box>
                 )
               }
@@ -421,15 +435,25 @@ export const register: Register = (on, options) => {
                     <Text color={COLOR[one.state]} dimColor={isQuiet || one.state === 'done'}>
                       {GLYPH[one.state] ?? '·'}{' '}
                     </Text>
-                    <Text bold={isHere} dimColor={isQuiet && !isHere} wrap="truncate-end">
-                      {one.label}
-                      {one.wakeAt !== undefined ? ` · ${wakeLabel(one.wakeAt)}` : ''}
-                    </Text>
+                    {/* A Button cannot truncate, so its Box clips a long label to the row. */}
+                    <Box height={1} flexShrink={1} overflow="hidden">
+                      <Button
+                        key={itemKey(item)}
+                        plain
+                        dimColor={isQuiet && !isHere}
+                        label={one.wakeAt !== undefined ? `${one.label} · ${wakeLabel(one.wakeAt)}` : one.label}
+                        onPress={enter(item)}
+                        autoFocus={isHere || undefined}
+                      />
+                    </Box>
+                    {/* The label gives up its cells to the PR chip, which would otherwise wrap under it. */}
                     {one.pr ? (
-                      <Text color={isQuiet ? undefined : PR_COLOR[one.pr.state]} dimColor={isQuiet}>
-                        {' '}
-                        {one.pr.short} {one.pr.state}
-                      </Text>
+                      <Box flexShrink={0}>
+                        <Text color={isQuiet ? undefined : PR_COLOR[one.pr.state]} dimColor={isQuiet}>
+                          {' '}
+                          {one.pr.short} {one.pr.state}
+                        </Text>
+                      </Box>
                     ) : null}
                   </Box>
                   {!isQuiet && one.line !== undefined ? (
@@ -457,11 +481,8 @@ export const register: Register = (on, options) => {
             </Box>
           )}
         </Box>
-        {/* Drawn nowhere: one Button per item for the ring and Enter, then the hotkeys. */}
+        {/* Drawn nowhere: the hotkeys. */}
         <Box height={0} overflow="hidden">
-          {flat.map(item => (
-            <Button key={itemKey(item)} plain label="" onPress={enter(item)} autoFocus={item === selected ? true : undefined} />
-          ))}
           {keys}
         </Box>
       </Box>

data/mod/tests/contract.test.tsx

@@ -17,7 +17,5 @@ test("the rows the pane reads are the ones the gem's Snapshot writes", () => {
     ['settled', 'c3', 'put away', 'done', true],
   ])
   expect(rows[1]?.pr).toEqual({ short: '#7', state: 'open', url: 'https://github.com/o/r/pull/7' })
-  expect(rows[0]?.cwd).toBe('/tmp/proj')
   expect(rows[0]?.isWaiting).toBe(false)
-  expect(rows[0]?.isTerminal).toBe(false)
 })

data/mod/tests/pane.test.tsx

@@ -12,7 +12,7 @@ const PANE = {
 const ROWS = [
   { section: 'needs_you', id: 'a1', label: 'needs an answer', state: 'blocked', actionable: true, line: 'confirm: drop it?' },
   { section: 'active', id: 'b2', label: 'still going', state: 'working', actionable: true, line: 'running bin/ci', pr: { short: '#7', state: 'open', url: 'https://github.com/o/r/pull/7' } },
-  { section: 'active', id: 'uuid-term', label: 'a terminal', state: 'working', actionable: false, isTerminal: true },
+  { section: 'active', id: 'uuid-term', label: 'a terminal', state: 'working', actionable: false },
   { section: 'settled', id: 'c3', label: 'put away', state: 'done', actionable: true },
 ]
 
@@ -78,18 +78,18 @@ test("rows sit under the gem's sections, Settled folded until za opens it", asyn
     expect(await ui.find({ type: 'Text', text: /Settled · 1/ })).toBeDefined()
     expect(await ui.find({ type: 'Text', text: /confirm: drop it\?/ })).toBeDefined()
     expect(await ui.find({ type: 'Text', text: /#7 open/ })).toBeDefined()
-    expect(await ui.find({ type: 'Text', text: /1 folded/ })).toBeDefined()
-    expect(await ui.find({ type: 'Text', text: /put away/ })).toBeUndefined()
+    expect(await ui.find({ text: /1 folded/ })).toBeDefined()
+    expect(await ui.find({ text: /put away/ })).toBeUndefined()
     await ui.press({ key: 'g' })
     await ui.press({ key: 'e' })
     await ui.press({ key: 'z' })
     expect(await ui.find({ type: 'Button', key: 'x' })).toBeUndefined()
     await ui.press({ key: 'a' })
-    expect(await ui.find({ type: 'Text', text: /put away/ })).toBeDefined()
+    expect(await ui.find({ text: /put away/ })).toBeDefined()
     expect(await ui.find({ type: 'Button', key: 'x' })).toBeDefined()
     await ui.press({ key: 'z' })
     await ui.press({ key: 'c' })
-    expect(await ui.find({ type: 'Text', text: /put away/ })).toBeUndefined()
+    expect(await ui.find({ text: /put away/ })).toBeUndefined()
     // Cursor and folds live in session state, so put them back for the next surface.
     await ui.press({ key: 'g' })
     await ui.press({ key: 'g' })
@@ -114,7 +114,7 @@ test('the session the pane sits in leads the list under This session, with its o
   })
   const ui = await $.ui.mount({ ...PANE, surface: 'terminal' })
   expect(await ui.find({ type: 'Text', text: /^This session$/ })).toBeDefined()
-  expect(await ui.find({ type: 'Text', text: /needs an answer/ })).toBeDefined()
+  expect(await ui.find({ text: /needs an answer/ })).toBeDefined()
   expect(await ui.find({ type: 'Text', text: /Needs you/ })).toBeUndefined()
   await ui.press({ key: 'row:a1' })
   expect(written).toEqual([])
@@ -172,6 +172,24 @@ test('Enter asks the attached inbox for the row, naming this session, and refuse
   await ui.unmount()
 })
 
+test('a click on a row puts the cursor on it before it asks for the switch', async ($, on) => {
+  mock.env(on, { HOME: '/Users/me' })
+  mock.clock(on, { now: 1_700_000_000_000 })
+  on('state.get', ($, e, next) => (e.key === 'rows' ? seeded(ROWS) : e.key === 'writtenAt' ? seeded(1_700_000_000) : next(e)))
+  const written: { path: string; text: string }[] = []
+  on('fs.write', ($, e) => {
+    written.push({ path: e.path, text: e.text })
+    return { value: undefined }
+  })
+  const ui = await $.ui.mount({ ...PANE, surface: 'terminal' })
+  expect((await ui.find({ key: 'row:b2' }))?.props.label).toBe('still going')
+  await ui.press({ key: 'row:b2' })
+  await ui.press({ key: 'x' })
+  expect(written.map(one => one.path)).toEqual(['/Users/me/.config/claude-inbox/switch.json', '/Users/me/.config/claude-inbox/actions/pane-1700000000000.json'])
+  expect(JSON.parse(written[1]?.text ?? '{}')).toMatchObject({ action: 'settle', id: 'b2' })
+  await ui.unmount()
+})
+
 test('an unfocused pane says how to focus it', async ($, on) => {
   mock.env(on, { HOME: '/Users/me' })
   mock.clock(on, { now: 1_700_000_000_000 })

data/mod/tests/snapshot.fixture.ts

@@ -13,8 +13,7 @@ export const SNAPSHOT = `{
         "session": "u-a1",
         "label": "needs an answer",
         "state": "blocked",
-        "actionable": true,
-        "cwd": "/tmp/proj"
+        "actionable": true
       }
     ],
     "active": [
@@ -24,7 +23,6 @@ export const SNAPSHOT = `{
         "label": "still going",
         "state": "working",
         "actionable": true,
-        "cwd": "/tmp/proj",
         "pr": {
           "short": "#7",
           "state": "open",
@@ -39,8 +37,7 @@ export const SNAPSHOT = `{
         "session": "u-c3",
         "label": "put away",
         "state": "done",
-        "actionable": true,
-        "cwd": "/tmp/proj"
+        "actionable": true
       }
     ]
   }

data/mod/types/index.d.ts

@@ -10,8 +10,6 @@ export type InboxRow = {
   state: string
   actionable: boolean
   isWaiting: boolean
-  isTerminal: boolean
-  cwd?: string
   line?: string
   wakeAt?: number | 'until_woken'
   remote?: string

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: claude-inbox
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Jordan Byron
@@ -128,7 +128,6 @@ files:
 - lib/claude_inbox/rate_limits.rb
 - lib/claude_inbox/reaper.rb
 - lib/claude_inbox/records.rb
-- lib/claude_inbox/remote.rb
 - lib/claude_inbox/remote/http.rb
 - lib/claude_inbox/remote/icon.png
 - lib/claude_inbox/remote/icon.svg

data/lib/claude_inbox/remote.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module ClaudeInbox
-  # Starting sessions from another device. App reaches it only through
-  # Remote::Listener.
-  module Remote
-  end
-end
-
-require_relative "remote/listener"