claude-inbox 0.6.0 → 0.7.0

data/lib/claude_inbox/cli.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "tmpdir"
+require_relative "app"
+require_relative "config"
+require_relative "headless"
+require_relative "mod"
+require_relative "updater"
+require_relative "writer_lock"
+
+module ClaudeInbox
+  # What `claude-inbox` does with its arguments: install the pane, update
+  # claude-inbox, or launch the inbox. `run` is true when it succeeded.
+  class CLI
+    USAGE = <<~USAGE
+      Usage: claude-inbox [options]
+             claude-inbox install [--force]
+             claude-inbox update
+    USAGE
+
+    # `lock` stands in for the writer lock a live launch takes.
+    def initialize(argv, env: ENV, config: Config::PATH, lock: nil, out: $stdout)
+      @argv = argv
+      @env = env
+      @config = config
+      @lock = lock
+      @out = out
+    end
+
+    def run
+      case @argv.first
+      when "install" then install
+      when "update" then update
+      else launch
+      end
+    end
+
+    # The launch flags, the config file's before the typed ones. 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.
+    def options
+      @options ||= begin
+        typed = parse(@argv)
+        options = typed[:fixture] ? typed : parse(Config.argv(@argv, path: @config))
+        env = typed[:fixture] ? {} : @env
+        options.merge(listen: Remote::Listener.options(env, flag: options[:listen], modes: options[:allow_modes]))
+      end
+    rescue OptionParser::ParseError, ArgumentError => e
+      abort "claude-inbox: #{e.message}"
+    end
+
+    # The keywords App is built with. A live launch takes the writer lock
+    # here: the first inbox you can see is the snapshot's writer, and a
+    # second one reads along, writing and deleting nothing.
+    def app_options
+      opts = options[:fixture] ? fixture_options : live_options
+      opts[:color] = options[:color]
+      return opts if options[:fixture] || writer_lock.take(role: "inbox")
+      opts.merge(store: Store.new(writable: false, relay: Actions.new), reaper: Reaper.disabled,
+        snapshot: Snapshot.disabled, actions: Actions.disabled, pane_offer: Mod::Offer.disabled)
+    end
+
+    private
+
+    def install
+      force = false
+      subcommand("install") { |p| p.on("--force", "Replace any other copy of the pane") { force = true } }
+      begin
+        installed = Mod.install(force: force)
+      rescue JSON::ParserError
+        abort "claude-inbox: ~/.claude/settings.json is not valid JSON, so it was left alone"
+      end
+      installed.removed.each { |dir| @out.puts "Removed #{dir} from ~/.claude/settings.json." }
+      @out.puts "The pane now runs #{Mod::COMMAND || "claude-inbox from your PATH"}." if installed.command_set
+      @out.puts(installed.added ? "Added the pane to ~/.claude/settings.json. New Claude Code sessions load it; /inbox opens it." :
+        "The pane is already in ~/.claude/settings.json.")
+      true
+    end
+
+    def update
+      subcommand("update")
+      updater = Updater.new
+      begin
+        update = updater.check(force: true)
+      rescue Updater::Error => e
+        abort "claude-inbox: #{e.message}"
+      end
+      unless update
+        @out.puts((updater.kind == :gem) ? "claude-inbox #{VERSION} is the latest release." : "main is up to date.")
+        return true
+      end
+      @out.puts update.installing
+      applied = updater.apply
+      abort "claude-inbox: #{applied.output.strip}" unless applied.success?
+      @out.puts((update.kind == :gem) ? "Installed claude-inbox #{update.latest}." : "main is at #{update.latest}.")
+      true
+    end
+
+    def launch
+      options
+      # Crash traces go here instead of the alt screen when set.
+      $stderr.reopen(@env["CLAUDE_INBOX_STDERR"], "a") if @env["CLAUDE_INBOX_STDERR"]
+      return headless if options[:headless]
+      auto_update if options[:auto_update]
+      # So the pane settings.json names is the installed version's, after a gem update too.
+      Mod.link unless options[:fixture]
+      App.new(**app_options).run
+      true
+    end
+
+    def headless
+      abort "claude-inbox: --headless takes no --fixture" if options[:fixture]
+      Headless.new(client: AgentsClient.new, store: Store.new, updater: updater).run
+    end
+
+    # Only what a check within the day already found: a cold launch never waits
+    # on the network. The relaunch is the new version's launch; a failure leaves
+    # this one to start as usual.
+    def auto_update
+      return unless (update = updater&.cached)
+      @out.puts update.installing
+      applied = updater.apply
+      applied.success? ? updater.relaunch(@argv) : warn("claude-inbox: #{applied.output.strip}")
+    end
+
+    def fixture_options
+      fixtures = File.dirname(options[:fixture])
+      # 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")
+      {client: FixtureClient.new(options[:fixture]),
+       store: Store.new(path: nil),
+       pull_requests: PullRequests.new(cache_path: File.join(fixtures, "gh-pr-status-cache.json"), resolved_path: nil, gh: nil),
+       listen: options[:listen]&.merge(fixture: true, pairing: Remote::Pairing.new(path: File.join(dir, "listen.json")),
+         lock_path: File.join(dir, "listen.lock"), images_dir: File.join(dir, "images"))}
+    end
+
+    # 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 here, and only when asked for.
+    def live_options
+      client = AgentsClient.new
+      store = Store.new
+      {client: client, store: store, reaper: options[:reap] ? Reaper.new(client, store) : Reaper.disabled,
+       snapshot: Snapshot.new, switch: Switch.new, actions: Actions.new, pane_offer: Mod::Offer.new,
+       listen: options[:listen], updater: updater,
+       # The typed arguments, not the config's: a relaunch reads the config again.
+       argv: @argv}
+    end
+
+    def updater
+      @updater ||= Updater.new if options[:update_check] && !options[:fixture]
+    end
+
+    # Held for the life of this process by this reference.
+    def writer_lock = (@lock ||= WriterLock.new)
+
+    def parse(argv)
+      opts = {color: true, update_check: true}
+      parser = OptionParser.new(USAGE) do |p|
+        p.on("--version", "Print the version") {
+          @out.puts VERSION
+          exit
+        }
+        p.on("--mod-dir", "Print the pane's directory, for CLAUDE_CODE_PLUGIN_DIRS") {
+          @out.puts Mod.link(force: true)
+          exit
+        }
+        p.on("--fixture PATH", "Read sessions from an agents.json instead of the daemon") { |path| opts[:fixture] = path }
+        p.on("--headless", "Keep the pane's snapshot fresh without a screen") { opts[:headless] = true }
+        p.on("--reap", "Delete background sessions idle 14 days") { opts[:reap] = true }
+        p.on("--no-color", "Draw without color") { opts[:color] = false }
+        p.on("--auto-update", "Install a release found today before launching") { opts[:auto_update] = true }
+        p.on("--no-update-check", "Never look for a newer release") { opts[:update_check] = false }
+        # --listen-lan wins over --listen, whichever came last.
+        p.on("--listen[=PORT]", "Let a phone on this Mac start sessions") { |port| opts[:listen] = {lan: false, port: port} unless opts.dig(:listen, :lan) }
+        p.on("--listen-lan[=PORT]", "Let a phone on your network start sessions") { |port| opts[:listen] = {lan: true, port: port} }
+        p.on("--listen-allow-modes=MODES", "The permission modes a phone may start in") { |modes| opts[:allow_modes] = modes }
+      end
+      strictly(parser, argv)
+      opts
+    end
+
+    def subcommand(name)
+      parser = OptionParser.new(USAGE)
+      yield parser if block_given?
+      strictly(parser, @argv.drop(1))
+    rescue OptionParser::ParseError => e
+      abort "claude-inbox #{name}: #{e.message}"
+    end
+
+    # Exact names only, so a typo is an error rather than the flag it abbreviates.
+    def strictly(parser, argv)
+      parser.require_exact = true
+      rest = parser.parse(argv)
+      raise OptionParser::InvalidArgument, rest.first if rest.any?
+    end
+  end
+end

data/lib/claude_inbox/input.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "tty-reader"
+require_relative "mouse"
+require_relative "paste"
+
+module ClaudeInbox
+  # The tty's keypress stream decoded into pastes, mouse reports and named
+  # keys. Hides what tty-reader does with ESC, echo and a paste, so App sees
+  # events and not the raw bytes.
+  class Input
+    def initialize(input, out)
+      @input = input
+      @reader = TTY::Reader.new(input: input, output: out, interrupt: :noop)
+      @paste = Paste.new
+    end
+
+    def pasting? = @paste.pasting?
+
+    # The next raw read, or nil when nothing has arrived.
+    def read
+      pasting? ? read_pasted : @reader.read_keypress(echo: false, raw: false, nonblock: true)
+    end
+
+    # `[:paste, text]`, `[:mouse, event]` and `[:key, name, raw]`, in the
+    # order they arrived; `name` is the reader's symbol for a key it knows,
+    # else the raw string.
+    def events(raw)
+      @paste.feed(raw).flat_map do |kind, text|
+        next [[:paste, text]] if kind == :paste
+        mouse = Mouse.events(text)
+        next mouse.map { |e| [:mouse, e] } if mouse.any?
+        split_keys(text).map { |k| [:key, key_name(k), k] }
+      end
+    end
+
+    # A paste typed out: `[name, raw]` per character.
+    def typed(text) = text.each_char.map { |c| [key_name(c), c] }
+
+    private
+
+    # As much of an open paste as has arrived, read straight off the tty:
+    # the reader switches echo off and back on around every character, and
+    # on a long paste that is most of the wait.
+    def read_pasted
+      return nil unless @input.wait_readable(0.1)
+      out = +""
+      while out.size < 65_536 && @input.wait_readable(0) && (c = @input.getc)
+        out << c
+      end
+      out
+    end
+
+    def key_name(key) = @reader.console.keys[key] || key
+
+    # tty-reader glues ESC to whatever arrives within 100ms, so a fast
+    # "esc gg" comes in as one unknown key "\egg". Vim hands make that
+    # constantly. Unknown ESC-prefixed strings become ESC + the rest.
+    def split_keys(key)
+      return [key] if key.size <= 1 || @reader.console.keys.key?(key)
+      return [key] unless key.start_with?("\e")
+      ["\e"] + key[1..].chars
+    end
+  end
+end

data/lib/claude_inbox/job_state.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "time"
 
 module ClaudeInbox
   # What the daemon writes about a background session in
@@ -16,7 +17,7 @@ module ClaudeInbox
   # `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, the color `/color`
   # set on the session, which `claude agents --json` drops, and `intent`, the
-  # prompt the session was started from.
+  # prompt the session was started from, and `createdAt`, when it was.
   #
   # Never cached. A color changes the moment you type `/color`, so every poll
   # asks the file again.
@@ -64,7 +65,7 @@ module ClaudeInbox
       nil
     end
 
-    attr_reader :pr_urls, :color, :intent, :bridge_id
+    attr_reader :pr_urls, :color, :intent, :bridge_id, :created_at
 
     def initialize(hash)
       @detail = hash["detail"]
@@ -77,6 +78,7 @@ module ClaudeInbox
       @color = hash["color"]
       @intent = hash["intent"]
       @bridge_id = hash["bridgeSessionId"]
+      @created_at = time(hash["createdAt"])
       @flags = hash["respawnFlags"] || []
     end
 
@@ -122,5 +124,11 @@ module ClaudeInbox
     def count_label = "#{tasks} #{plural("task", tasks)}"
 
     def plural(word, n) = (n == 1) ? word : "#{word}s"
+
+    def time(iso)
+      iso && Time.iso8601(iso)
+    rescue ArgumentError
+      nil
+    end
   end
 end

data/lib/claude_inbox/keymap.rb

@@ -19,15 +19,13 @@ module ClaudeInbox
       "G" => :bottom,
       :ctrl_d => :half_page_down, :ctrl_u => :half_page_up,
       :ctrl_f => :page_down, :ctrl_b => :page_up,
-      :ctrl_e => :peek_down, :ctrl_y => :peek_up,
-      "J" => :peek_down, "K" => :peek_up,
       # actions
       :return => :activate, :enter => :activate, "l" => :activate,
-      "h" => :collapse,
+      "h" => :fold_close,
       "s" => :snooze, "u" => :wake, "a" => :alias, "x" => :settle, "X" => :stop,
       :ctrl_x => :delete,
       "o" => :open_pr, "P" => :link_pr, "t" => :toggle_pin, "w" => :open_remote,
-      "R" => :refresh, "U" => :update, "p" => :toggle_peek, "n" => :new_session, "N" => :remote_pairing,
+      "R" => :refresh, "U" => :update, "n" => :new_session, "N" => :remote_pairing,
       :tab => :next_section, :back_tab => :prev_section,
       "/" => :filter, :escape => :escape,
       "q" => :quit, :ctrl_c => :quit

data/lib/claude_inbox/mod.rb

@@ -41,9 +41,9 @@ module ClaudeInbox
     # rather than rewrite a settings file it cannot read.
     def self.install(settings: SETTINGS, link: LINK, dir: DIR, force: false, command: COMMAND)
       self.link(link: link, dir: dir, force: true)
-      json = File.exist?(settings) ? JSON.parse(File.read(settings)) : {}
+      json = read_settings(settings)
       env = json["env"] ||= {}
-      dirs = env["CLAUDE_CODE_PLUGIN_DIRS"].to_s.split(File::PATH_SEPARATOR).map(&:strip).reject(&:empty?)
+      dirs = plugin_dirs(env["CLAUDE_CODE_PLUGIN_DIRS"])
       kept = dirs.reject { |d| force && d != link && plugin?(d) }
       wanted = kept.include?(link) ? kept : [*kept, link]
       options = json.dig("pluginConfigs", NAME, "options") || {}
@@ -66,8 +66,7 @@ module ClaudeInbox
     # worktree's included. A settings file it cannot read counts as yes, since
     # install would refuse to touch it.
     def self.installed?(settings: SETTINGS)
-      json = File.exist?(settings) ? JSON.parse(File.read(settings)) : {}
-      json.dig("env", "CLAUDE_CODE_PLUGIN_DIRS").to_s.split(File::PATH_SEPARATOR).any? { |d| plugin?(d.strip) }
+      plugin_dirs(read_settings(settings).dig("env", "CLAUDE_CODE_PLUGIN_DIRS")).any? { |d| plugin?(d) }
     rescue JSON::ParserError, Errno::EACCES
       true
     end
@@ -101,6 +100,10 @@ module ClaudeInbox
     rescue Errno::ENOENT, Errno::ENOTDIR, Errno::EACCES, JSON::ParserError
       false
     end
-    private_class_method :plugin?
+
+    def self.read_settings(path) = File.exist?(path) ? JSON.parse(File.read(path)) : {}
+
+    def self.plugin_dirs(value) = value.to_s.split(File::PATH_SEPARATOR).map(&:strip).reject(&:empty?)
+    private_class_method :plugin?, :read_settings, :plugin_dirs
   end
 end

data/lib/claude_inbox/mouse.rb

@@ -11,7 +11,7 @@ module ClaudeInbox
     Event = Struct.new(:kind, :row, :col)
 
     # A raw keypress can glue several reports together the same way a fast
-    # "esc gg" glues onto one read (see App#split_keys), so this scans
+    # "esc gg" glues onto one read (see Input#split_keys), so this scans
     # rather than matching once.
     def self.events(raw)
       raw.scan(SEQUENCE).filter_map do |cb, col, row, type|

data/lib/claude_inbox/pull_requests.rb

@@ -57,11 +57,10 @@ module ClaudeInbox
   class PullRequests
     REFRESH_AFTER = 60
 
-    CLAUDE_DIR = File.join(Dir.home, ".claude")
+    CACHE_PATH = File.join(Dir.home, ".claude", "gh-pr-status-cache.json")
     RESOLVED_PATH = File.join(Dir.home, ".config", "claude-inbox", "prs.json")
 
-    def initialize(cache_path: File.join(CLAUDE_DIR, "gh-pr-status-cache.json"), resolved_path: RESOLVED_PATH,
-      gh: "gh", clock: -> { Time.now })
+    def initialize(cache_path: CACHE_PATH, resolved_path: RESOLVED_PATH, gh: "gh", clock: -> { Time.now })
       @cache_path = cache_path
       @resolved_path = resolved_path
       @gh = gh

data/lib/claude_inbox/remote/listener.rb

@@ -67,13 +67,12 @@ module ClaudeInbox
       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.
-      def self.options(argv, env)
-        flags = argv.filter_map { |arg| arg.match(/\A--listen(-lan)?(?:=(.*))?\z/) }
+      # asks for it. `flag` is the listen flag's `lan:` and `port:`, and
+      # `modes` --listen-allow-modes, both as typed.
+      def self.options(env, flag: nil, modes: nil)
         lan, port =
-          if flags.any?
-            flag = flags.reverse.find { |m| m[1] } || flags.last
-            [!flag[1].nil?, flag[2]]
+          if flag
+            flag.values_at(:lan, :port)
           elsif !(value = env["CLAUDE_INBOX_LISTEN"].to_s.strip).empty?
             m = value.match(/\A(?:(lan)(?::(.*))?|(\d+))\z/i)
             raise ArgumentError, "CLAUDE_INBOX_LISTEN is a port, lan or lan:PORT, not #{value}" unless m
@@ -81,7 +80,7 @@ module ClaudeInbox
           else
             return nil
           end
-        modes = argv.filter_map { |arg| arg[/\A--listen-allow-modes=(.*)\z/, 1] }.last || env["CLAUDE_INBOX_LISTEN_ALLOW_MODES"]
+        modes ||= env["CLAUDE_INBOX_LISTEN_ALLOW_MODES"]
         {port: port_option(port), lan: lan, allowed_modes: modes_option(modes)}
       end
 

data/lib/claude_inbox/renderer.rb

@@ -11,18 +11,17 @@ 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
-    Frame = Struct.new(:lines, :items, :top, :list_width)
+    Frame = Struct.new(:lines, :items, :top)
 
     CHROME_ROWS = 2 # header + footer
-    MIN_LIST_WIDTH = 44 # with the peek open, the list keeps at least this many columns
 
     def self.body_height(height) = height - CHROME_ROWS
 
-    # What App hands Renderer for one frame. `peek` is a Peek::View and
-    # `listening` a Remote::Listener::Snapshot.
-    View = Data.define(:width, :height, :now, :selected, :top, :expanded, :peek, :modal, :screen,
+    # What App hands Renderer for one frame. `listening` is a
+    # Remote::Listener::Snapshot.
+    View = Data.define(:width, :height, :now, :selected, :top, :expanded, :modal, :screen,
       :status, :usage, :filter, :filter_editing, :tick, :loading, :listening) do
-      def initialize(width:, height:, now:, selected: nil, top: 0, expanded: {}, peek: nil, modal: nil, screen: nil,
+      def initialize(width:, height:, now:, selected: nil, top: 0, expanded: {}, modal: nil, screen: nil,
         status: nil, usage: nil, filter: nil, filter_editing: false, tick: 0, loading: nil, listening: nil) = super
     end
 
@@ -60,7 +59,7 @@ module ClaudeInbox
 
     KEYS = [
       ["j/k", "move"], ["⏎", "attach"], ["n", "new"], ["t", "pin"], ["s", "snooze"], ["u", "wake"],
-      ["a", "alias"], ["o", "PR"], ["x", "settle"], ["p", "peek"], ["⇥", "section"],
+      ["a", "alias"], ["o", "PR"], ["x", "settle"], ["⇥", "section"],
       ["za", "fold"], ["/", "filter"], ["q", "quit"]
     ].freeze
 
@@ -76,13 +75,12 @@ module ClaudeInbox
     def frame(sections, view)
       return full_screen(sections, view) if view.screen
       width, height, selected = view.width, view.height, view.selected
-      list_w = width_for_list(width, view.peek)
       view_h = Renderer.body_height(height)
       body, items =
         if view.loading
-          [loading_state(list_w, view_h, view.loading, view.tick), []]
+          [loading_state(width, view_h, view.loading, view.tick), []]
         else
-          body_lines(sections, list_w, view)
+          body_lines(sections, width, view)
         end
 
       top = clamp_top(view.top, body.size, view_h, items, selected)
@@ -91,26 +89,13 @@ module ClaudeInbox
       visible += [""] * (view_h - visible.size)
       visible_items += [nil] * (view_h - visible_items.size)
 
-      if view.peek
-        peek_w = width - list_w - 1
-        peek_lines = peek_pane(view.peek, peek_w, view_h)
-        visible = visible.each_with_index.map do |l, i|
-          Text.pad(l, list_w) + @p.dim("│") + Text.pad(peek_lines[i] || "", peek_w)
-        end
-      end
-
       lines = [header(sections, width, view)] + visible.map { |l| Text.pad(l, width) } + [footer(width, view)]
       lines = overlay(lines, view.modal, width) if view.modal
-      Frame.new(lines, [nil] + visible_items + [nil], top, list_w)
+      Frame.new(lines, [nil] + visible_items + [nil], top)
     end
 
     private
 
-    def width_for_list(width, peek)
-      return width unless peek
-      [(width * 0.4).floor, MIN_LIST_WIDTH].max.clamp(0, width)
-    end
-
     def clamp_top(top, size, view_h, items, selected)
       idx = items.index { |item| item && item.key == selected }
       top = idx - 2 if idx && idx - 2 < top # keep the section title in view
@@ -124,7 +109,7 @@ module ClaudeInbox
       body = view.screen[:lines].first(view_h)
       body += [""] * (view_h - body.size)
       lines = [header(sections, width, view)] + body.map { |l| Text.pad(l, width) } + [Text.pad(" " + view.screen[:footer], width)]
-      Frame.new(lines, [nil] * view.height, view.top, width)
+      Frame.new(lines, [nil] * view.height, view.top)
     end
 
     # ----- chrome -------------------------------------------------------------
@@ -242,7 +227,7 @@ module ClaudeInbox
         return [empty_state(width), []]
       end
       selected = view.selected
-      sections.each_section do |name, rows|
+      sections.each_pair do |name, rows|
         next if rows.empty?
         lines << "" << section_title(name, rows.size, width)
         items << nil << nil
@@ -391,7 +376,7 @@ module ClaudeInbox
       pr ? base + @p.dim(" · ") + pr : base
     end
 
-    # "#885 open". Only the first PR is shown; the peek subtitle lists them all.
+    # "#885 open". Only the first PR is shown.
     def pr_badge(s, section)
       pr = s.pr
       return nil unless pr
@@ -427,18 +412,6 @@ module ClaudeInbox
       path.start_with?(@home) ? path.sub(@home, "~") : path
     end
 
-    # ----- peek ---------------------------------------------------------------
-
-    def peek_pane(peek, width, height)
-      bar = Text.pad(" " + (peek.title || ""), width)
-      out = [@p.inverse(bar)]
-      out << Text.pad(" " + @p.dim(peek.subtitle.to_s), width) if peek.subtitle
-      body_h = height - out.size
-      wrapped = peek.lines.flat_map { |l| Text.wrap(l, width - 1) }
-      wrapped.last(body_h).each { |l| out << Text.pad(" " + l, width) }
-      out
-    end
-
     # ----- modal --------------------------------------------------------------
 
     # Centre a block of lines over the frame.

data/lib/claude_inbox/session.rb

@@ -78,6 +78,10 @@ module ClaudeInbox
     # From `/color`; interactive sessions have no job file, so never one.
     def color = job_state&.color
 
+    # A respawn moves `started_at` to the new process; the job file keeps
+    # when the session itself began.
+    def created_at = job_state&.created_at || started_at
+
     # The prompt this session was started with.
     def intent = job_state&.intent
 

data/lib/claude_inbox/slash_commands.rb

@@ -24,13 +24,12 @@ module ClaudeInbox
     # The project wins over the home directory when both define the same
     # name, as it does in the CLI.
     def list(cwd:, home:)
-      found = {}
-      add = ->(cmd) { found[cmd.name] ||= cmd }
-      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)
+      [
+        *from_dir(File.join(cwd, ".claude")),
+        *from_dir(File.join(home, ".claude")),
+        *plugins(home),
+        *synced(home)
+      ].uniq(&:name).sort_by(&:name)
     end
 
     def match(commands, query)

data/lib/claude_inbox/store/row.rb

@@ -71,7 +71,7 @@ module ClaudeInbox
       def settled?
         return true if hand_settled?
         return false if UNSETTLEABLE.include?(session.effective_state)
-        started = session.started_at.to_i
+        started = session.created_at.to_i
         ours = session.prs.select(&:known?).reject { |pr| pr.resolved_before?(started) }
         ours.any? && ours.all? { |pr| pr.resolved_since?(started) }
       end

data/lib/claude_inbox/store/sections.rb

@@ -4,8 +4,6 @@ module ClaudeInbox
   class Store
     # The Rows of one poll, grouped and ordered, and where the cursor may land among them.
     Sections = Struct.new(:pinned, :needs_you, :active, :snoozed, :settled) do
-      def each_section(&) = each_pair(&)
-
       def all = values.flatten(1)
 
       def row(selection)
@@ -20,7 +18,7 @@ module ClaudeInbox
       def section_of(selection)
         return nil if selection.nil?
         return selection.key if selection.fold?
-        each_section { |name, rows| return name if rows.any? { |r| r.key == selection.key } }
+        each_pair { |name, rows| return name if rows.any? { |r| r.key == selection.key } }
         nil
       end
 
@@ -35,8 +33,7 @@ module ClaudeInbox
 
       # An empty fold is left out, since there is nothing under it to open.
       def stops(expanded)
-        members.filter_map do |name|
-          rows = self[name]
+        each_pair.filter_map do |name, rows|
           if !Store.folded?(name, expanded) then [name, rows.select(&:selectable?).map { |r| Selection.row(r.key) }]
           elsif rows.any? then [name, [Selection.fold(name)]]
           end

data/lib/claude_inbox/store.rb

@@ -116,7 +116,7 @@ module ClaudeInbox
     def pr_for(id) = @mutex.synchronize { @entries[id] && Entry.new(@entries[id]).pr }
 
     def pr_overrides
-      @mutex.synchronize { @entries.transform_values { |e| Entry.new(e).pr }.select { |_, url| url } }
+      @mutex.synchronize { @entries.transform_values { |e| Entry.new(e).pr }.compact }
     end
 
     # A copy, not the live entry: the reaper decides a deletion on this row

data/lib/claude_inbox/vt_screen.rb

@@ -4,12 +4,10 @@ require "strscan"
 require "unicode/display_width"
 
 module ClaudeInbox
-  # A deliberately small cursor-addressed screen model. `claude logs` emits a
-  # replay of the session's terminal output — cursor moves, erase-line, SGR —
-  # not plain text, and words are often separated by cursor motion instead of
-  # spaces. Stripping escapes therefore yields garbage; feeding them through a
-  # grid does not. This is not a VT emulator: it handles the handful of
-  # sequences the replay actually uses and ignores the rest.
+  # A deliberately small cursor-addressed screen model that turns captured
+  # terminal output into the lines it would show; bin/screens reads the
+  # inbox's own frames through it. This is not a VT emulator: it handles the
+  # handful of sequences claude's output actually uses and ignores the rest.
   class VtScreen
     CSI = /\e\[([0-9;?]*)([A-Za-z@`])/
     OSC = /\e\][^\a\e]*(?:\a|\e\\)?/

data/lib/claude_inbox.rb

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