claude-inbox 0.1.0 → 0.2.0

data/lib/claude_inbox/poller.rb

@@ -2,7 +2,6 @@
 
 require_relative "reaper"
 require_relative "sessions"
-require_relative "store"
 
 module ClaudeInbox
   # Asks `claude agents` for the list off the main thread, every INTERVAL
@@ -15,11 +14,11 @@ module ClaudeInbox
   class Poller
     INTERVAL = 4
 
-    def initialize(client:, store:, pull_requests:, jobs_dir:, reaper:, queue:, interval: INTERVAL)
+    def initialize(client:, store:, pull_requests:, reaper:, queue:, interval: INTERVAL, clock: -> { Time.now })
       @client = client
+      @clock = clock
       @store = store
       @pull_requests = pull_requests
-      @jobs_dir = jobs_dir
       @reaper = reaper
       @queue = queue
       @interval = interval
@@ -55,8 +54,8 @@ module ClaudeInbox
     # dropped it. The gh refresh comes last and publishes again only if a PR
     # state moved.
     def once
-      now = Time.now
-      sessions = Sessions.load(client: @client, jobs_dir: @jobs_dir, pull_requests: @pull_requests, overrides: @store.pr_overrides)
+      now = @clock.call
+      sessions = Sessions.load(client: @client, pull_requests: @pull_requests, overrides: @store.pr_overrides)
       doomed = @reaper.due(sessions, now)
       @store.hide(doomed)
       @queue << [:sessions, sessions]
@@ -67,7 +66,7 @@ module ClaudeInbox
         @store.release(doomed - reaped)
       end
       @queue << [:sessions, sessions] if reaped != doomed
-      notice_reaped(reaped) if reaped.any?
+      @queue << [:notice, @reaper.report(reaped)] if reaped.any?
       fresh, moved = @pull_requests.refresh(sessions)
       @queue << [:sessions, fresh] if moved
     rescue => e
@@ -89,10 +88,5 @@ module ClaudeInbox
     end
 
     def paused? = @lock.synchronize { @paused }
-
-    def notice_reaped(keys)
-      word = (keys.size == 1) ? "session" : "sessions"
-      @queue << [:notice, "reaped #{keys.size} #{word} idle over #{Store::REAP_AFTER / 86_400}d — see #{@reaper.log_path}"]
-    end
   end
 end

data/lib/claude_inbox/rate_limits.rb

@@ -5,7 +5,7 @@ require "json"
 module ClaudeInbox
   # The subscription's 5-hour and 7-day usage, read from
   # ~/.claude/rate_limits.json. Nothing writes that file but the user's own
-  # status line script (README, "Usage"): `claude agents --json` says nothing
+  # status line script (README, "Setup"): `claude agents --json` says nothing
   # about limits and there is no CLI command for them, but every session hands
   # its status line a `rate_limits` object on each turn, so a one-line tee
   # there is the only source that costs no API calls. No file, or a file
@@ -13,6 +13,14 @@ module ClaudeInbox
   class RateLimits
     DEFAULT_PATH = File.join(Dir.home, ".claude", "rate_limits.json")
     STALE_AFTER = 15 * 60
+    # Named as Claude's own /usage screen names them, not by length, so the
+    # label never reads like the countdown beside it.
+    LABELS = {"five_hour" => "session", "seven_day" => "week"}.freeze
+
+    # `resets_at` is when the window rolls over, or nil if the file omits it.
+    Window = Data.define(:label, :percent, :resets_at) do
+      def initialize(label:, percent:, resets_at: nil) = super
+    end
 
     def initialize(path: DEFAULT_PATH)
       @path = path
@@ -20,9 +28,11 @@ module ClaudeInbox
       @data = nil
     end
 
-    # "usage 5h 23% · 7d 41%", or nil. Parses only when the file has changed,
-    # since render asks several times a second.
-    def label(now = Time.now)
+    # The windows the file reports, each with a whole percent and its reset
+    # time, or nil.
+    # Parses only when the file has changed, since render asks several times
+    # a second.
+    def windows(now = Time.now)
       mtime = File.mtime(@path)
       return nil if now - mtime > STALE_AFTER
       @data = parse if mtime != @mtime
@@ -36,11 +46,13 @@ module ClaudeInbox
 
     def parse
       hash = JSON.parse(File.read(@path))
-      parts = {"five_hour" => "5h", "seven_day" => "7d"}.filter_map do |key, word|
+      windows = LABELS.filter_map do |key, label|
         pct = hash.dig(key, "used_percentage")
-        "#{word} #{pct.round}%" if pct.is_a?(Numeric)
+        next unless pct.is_a?(Numeric)
+        resets_at = hash.dig(key, "resets_at")
+        Window.new(label, pct.round.clamp(0, 100), (Time.at(resets_at) if resets_at.is_a?(Numeric)))
       end
-      "usage " + parts.join(" · ") unless parts.empty?
+      windows unless windows.empty?
     rescue JSON::ParserError, TypeError
       nil
     end

data/lib/claude_inbox/reaper.rb

@@ -9,8 +9,8 @@ module ClaudeInbox
   #
   # The one thing in the inbox that destroys anything without being asked
   # first, so the whole of it lives here rather than spread through the poll
-  # loop: one public method, and one append-only log that is the last record
-  # a session ever existed once `claude rm` has taken its transcript.
+  # loop, along with the append-only log that is the last record a session
+  # ever existed once `claude rm` has taken its transcript.
   #
   # Unpushed work is safe by construction. `claude rm` refuses a worktree
   # holding commits that aren't pushed and reports a --discard-unpushed token
@@ -20,8 +20,6 @@ module ClaudeInbox
     RETRY_AFTER = 24 * 3600
     DEFAULT_LOG = File.join(Dir.home, ".config", "claude-inbox", "reaped.log")
 
-    attr_reader :log_path
-
     def initialize(client, store, log_path: DEFAULT_LOG, enabled: self.class.enabled?)
       @client = client
       @store = store
@@ -43,27 +41,26 @@ module ClaudeInbox
     # Raises if the log cannot be opened, before anything is deleted. No
     # audit trail, no reaping.
     def sweep(sessions, now)
-      return [] unless @enabled
       now_i = now.to_i
-      due = sessions.filter_map { |s| row_if_due(s, now_i) }
-      return [] if due.empty?
-      with_log { |log| due.filter_map { |row| reap(row, log, now_i) } }
+      rows = due_rows(sessions, now_i)
+      return [] if rows.empty?
+      with_log { |log| rows.filter_map { |row| reap(row, log, now_i) } }
     end
 
     # Keys `sweep` would go after right now, without touching any of them,
     # so the poller can hand the list over minus these before `claude rm`.
-    def due(sessions, now)
-      return [] unless @enabled
-      now_i = now.to_i
-      sessions.filter_map { |s| row_if_due(s, now_i)&.key }
+    def due(sessions, now) = due_rows(sessions, now.to_i).map(&:key)
+
+    def report(keys)
+      word = (keys.size == 1) ? "session" : "sessions"
+      "reaped #{keys.size} #{word} idle over #{Store::REAP_AFTER / 86_400}d — see #{@log_path}"
     end
 
     private
 
-    def row_if_due(session, now_i)
-      row = @store.row(session)
-      return nil unless row.reapable?(now_i)
-      backing_off?(row, now_i) ? nil : row
+    def due_rows(sessions, now_i)
+      return [] unless @enabled
+      sessions.map { |s| @store.row(s) }.select { |row| row.reapable?(now_i) && !backing_off?(row, now_i) }
     end
 
     def backing_off?(row, now_i)

data/lib/claude_inbox/renderer.rb

@@ -20,6 +20,13 @@ module ClaudeInbox
 
     Frame = Struct.new(:lines, :items, :top, :list_width)
 
+    # What App hands Renderer for one frame. `peek` is a Peek::View.
+    View = Data.define(:width, :height, :now, :selected, :top, :expanded, :peek, :modal, :screen,
+      :status, :usage, :filter, :filter_editing, :tick, :loading) do
+      def initialize(width:, height:, now:, selected: nil, top: 0, expanded: {}, peek: nil, modal: nil, screen: nil,
+        status: nil, usage: nil, filter: nil, filter_editing: false, tick: 0, loading: nil) = super
+    end
+
     SECTION_TITLES = {
       pinned: "PINNED",
       needs_you: "NEEDS YOU",
@@ -28,6 +35,8 @@ module ClaudeInbox
       settled: "SETTLED"
     }.freeze
 
+    SECTION_HUES = {pinned: :cyan, needs_you: :red, active: :yellow, snoozed: :purple}.freeze
+
     SPINNER = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
 
     # The first poll usually lands inside a second. Past LOADING_QUIET the
@@ -62,41 +71,34 @@ module ClaudeInbox
 
     def caret = ->(cell) { @p.inverse(cell) }
 
-    # opts: selected (id | :snoozed | :settled | nil), expanded ({snoozed:, settled:} => bool), top (scroll),
-    #       peek (Array<String> | nil), peek_title, modal (Array<String> | nil),
-    #       status (String | nil, a notice or error at the header's right end),
-    #       usage (String | nil, the rate-limit label after it), now (Time), filter (TextBuffer | nil), filter_editing,
-    #       tick (Integer, drives the spinner),
-    #       loading (Float seconds waited for the first poll, nil once it has landed),
-    #       screen ({lines:, footer:} takes over everything below the header)
-    def frame(sections, width:, height:, now:, **opts)
-      return full_screen(sections, width, height, now, opts) if opts[:screen]
-      selected = opts[:selected]
-      list_w = width_for_list(width, opts[:peek])
+    def frame(sections, view)
+      return full_screen(sections, view) if view.screen
+      width, height, now, selected = view.width, view.height, view.now, view.selected
+      list_w = width_for_list(width, view.peek)
       view_h = height - 2 # header + footer
       body, items =
-        if opts[:loading]
-          [loading_state(list_w, view_h, opts[:loading], opts[:tick].to_i), []]
+        if view.loading
+          [loading_state(list_w, view_h, view.loading, view.tick), []]
         else
-          body_lines(sections, list_w, selected, opts, now)
+          body_lines(sections, list_w, view, now)
         end
 
-      top = clamp_top(opts[:top] || 0, body.size, view_h, items, selected)
+      top = clamp_top(view.top, body.size, view_h, items, selected)
       visible = body[top, view_h] || []
       visible_items = items[top, view_h] || []
       visible += [""] * (view_h - visible.size)
       visible_items += [nil] * (view_h - visible_items.size)
 
-      if opts[:peek]
+      if view.peek
         peek_w = width - list_w - 1
-        peek_lines = peek_pane(opts[:peek], opts[:peek_title], opts[:peek_subtitle], peek_w, view_h)
+        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, opts, now)] + visible.map { |l| Text.pad(l, width) } + [footer(width, opts)]
-      lines = overlay(lines, opts[:modal], width) if opts[:modal]
+      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)
     end
 
@@ -114,53 +116,79 @@ module ClaudeInbox
       top.clamp(0, [size - view_h, 0].max)
     end
 
-    def full_screen(sections, width, height, now, opts)
-      view_h = height - 2
-      body = opts[:screen][:lines].first(view_h)
+    def full_screen(sections, view)
+      width = view.width
+      view_h = view.height - 2
+      body = view.screen[:lines].first(view_h)
       body += [""] * (view_h - body.size)
-      lines = [header(sections, width, opts, now)] + body.map { |l| Text.pad(l, width) } + [Text.pad(" " + opts[:screen][:footer], width)]
-      Frame.new(lines, [nil] * (view_h + 2), opts[:top] || 0, width)
+      lines = [header(sections, width, view)] + body.map { |l| Text.pad(l, width) } + [Text.pad(" " + view.screen[:footer], width)]
+      Frame.new(lines, [nil] * (view_h + 2), view.top, width)
     end
 
     # ----- chrome -------------------------------------------------------------
 
-    def header(sections, width, opts, now)
+    def header(sections, width, view)
       brand = " " + @theme.cyan_bold("▌ claude-inbox")
-      right = [opts[:status], opts[:usage]].compact.map { |s| @p.dim(s) }.join(@p.dim("  ·  "))
+      right = [view.status && @p.dim(view.status), view.usage && usage_meters(view.usage, view.now)].compact.join(@p.dim("  ·  "))
       right += " " unless right.empty?
       room = width - Text.width(brand) - Text.width(right) - 3
-      chips = opts[:loading] ? "" : header_chips(sections, compact: false)
+      chips = view.loading ? "" : header_chips(sections, compact: false)
       chips = header_chips(sections, compact: true) if Text.width(chips) > room
       chips = "" if Text.width(chips) > room
       Text.pad(brand + "   " + chips, width - Text.width(right)) + right
     end
 
+    # "session ██░░░░░░░░ 24% · 3h left" per window, drawn and colored the way
+    # the context bar in the user's status line is, so the two read alike.
+    def usage_meters(windows, now)
+      windows.map do |w|
+        filled = w.percent / 10
+        bar = "█" * filled + "░" * (10 - filled)
+        left = w.resets_at && w.resets_at.to_i - now.to_i
+        figure = left&.positive? ? "#{w.percent}% · #{Text.age(left)} left" : "#{w.percent}%"
+        "#{@p.dim(w.label)} #{@theme.public_send(usage_hue(w.percent), bar)} #{@p.dim(figure)}"
+      end.join("  ")
+    end
+
+    def usage_hue(percent)
+      if percent >= 90 then :red
+      elsif percent >= 70 then :yellow
+      else :green
+      end
+    end
+
     def header_chips(sections, compact:)
-      pn = sections.pinned.size
-      n = sections.needs_you.size
-      w = sections.active.count { |r| r.session.effective_state == "working" && !r.session.waiting_on_work? }
-      q = sections.active.count { |r| r.session.waiting_on_work? }
-      i = sections.all.count { |r| r.session.terminal? }
-      m = sections.all.count { |r| r.session.remote? }
-      z = sections.snoozed.size
-      d = sections.settled.size
-      chips = []
-      chips << @theme.cyan_bold(compact ? "★ #{pn}" : "★ #{pn} pinned") if pn > 0
-      chips << @theme.red_bold(compact ? "● #{n}" : "● #{n} need#{"s" if n == 1} you") if n > 0
-      chips << @theme.yellow(compact ? "✻ #{w}" : "✻ #{w} working") if w > 0
-      chips << @theme.yellow(compact ? "◌ #{q}" : "◌ #{q} idle") if q > 0
-      chips << @p.dim(compact ? "○ #{i}" : "○ #{i} terminal#{"s" if i > 1}") if i > 0
-      chips << @theme.blue(compact ? "⇅ #{m}" : "⇅ #{m} remote") if m > 0
-      chips << @theme.purple(compact ? "z #{z}" : "z #{z} snoozed") if z > 0
-      chips << @p.dim(compact ? "◦ #{d}" : "◦ #{d} settled") if d > 0
+      pinned = sections.pinned.size
+      needing = sections.needs_you.size
+      working = sections.active.count { |r| r.session.effective_state == "working" && !r.session.waiting_on_work? }
+      idle = sections.active.count { |r| r.session.waiting_on_work? }
+      terminals = sections.all.count { |r| r.session.terminal? }
+      remotes = sections.all.count { |r| r.session.remote? }
+      snoozed = sections.snoozed.size
+      settled = sections.settled.size
+      chips = [
+        header_chip(pinned, "★", "pinned", compact) { |s| @theme.cyan_bold(s) },
+        header_chip(needing, "●", "need#{"s" if needing == 1} you", compact) { |s| @theme.red_bold(s) },
+        header_chip(working, "✻", "working", compact) { |s| @theme.yellow(s) },
+        header_chip(idle, "◌", "idle", compact) { |s| @theme.yellow(s) },
+        header_chip(terminals, "○", "terminal#{"s" if terminals > 1}", compact) { |s| @p.dim(s) },
+        header_chip(remotes, "⇅", "remote", compact) { |s| @theme.blue(s) },
+        header_chip(snoozed, "z", "snoozed", compact) { |s| @theme.purple(s) },
+        header_chip(settled, "◦", "settled", compact) { |s| @p.dim(s) }
+      ].compact
       chips << @p.dim("nothing running") if sections.all.empty?
       chips.join(compact ? "  " : @p.dim("  ·  "))
     end
 
-    def footer(width, opts)
+    def header_chip(count, glyph, words, compact)
+      return unless count > 0
+      yield(compact ? "#{glyph} #{count}" : "#{glyph} #{count} #{words}")
+    end
+
+    def footer(width, view)
       text =
-        if opts[:filter_editing] then " " + @theme.cyan_bold("/") + line(opts[:filter], width - 2)
-        elsif opts[:filter] then " " + @theme.cyan_bold("/") + opts[:filter].to_s + @p.dim("  esc clears")
+        if view.filter_editing then " " + @theme.cyan_bold("/") + line(view.filter, width - 2)
+        elsif view.filter then " " + @theme.cyan_bold("/") + view.filter.to_s + @p.dim("  esc clears")
         else " " + KEYS.map { |k, d| @theme.cyan_bold(k) + " " + @p.dim(d) }.join("  ")
         end
       Text.pad(text, width)
@@ -172,40 +200,34 @@ module ClaudeInbox
       title = " #{SECTION_TITLES[name]} "
       count_s = " #{count} "
       fill = [width - 3 - Text.width(title) - Text.width(count_s), 0].max
-      color = section_color(name)
-      Text.pad(" " + color.call("▎") + color.call(@p.bold(title)) + @p.dim("─" * fill) + @p.dim(count_s), width)
+      Text.pad(" " + section_color(name, "▎") + section_color(name, @p.bold(title)) + @p.dim("─" * fill) + @p.dim(count_s), width)
     end
 
-    def section_color(name)
-      case name
-      when :pinned then ->(s) { @theme.cyan(s) }
-      when :needs_you then ->(s) { @theme.red(s) }
-      when :active then ->(s) { @theme.yellow(s) }
-      when :snoozed then ->(s) { @theme.purple(s) }
-      else ->(s) { @p.dim(s) }
-      end
+    def section_color(name, s)
+      hue = SECTION_HUES[name]
+      hue ? @theme.public_send(hue, s) : @p.dim(s)
     end
 
     # ----- body ---------------------------------------------------------------
 
-    def body_lines(sections, width, selected, opts, now)
+    def body_lines(sections, width, view, now)
       lines = []
       items = []
       if sections.all.empty?
         return [empty_state(width), []]
       end
-      expanded = opts[:expanded] || {}
+      selected = view.selected
       sections.each_section do |name, rows|
         next if rows.empty?
         lines << "" << section_title(name, rows.size, width)
         items << nil << nil
-        if Store.folded?(name, expanded)
+        if Store.folded?(name, view.expanded)
           lines << fold_toggle_line(name, rows.size, selected, width)
           items << Item.new(:fold_toggle, nil, name)
           next
         end
         rows.each do |row|
-          row_lines(row, name, selected, width, now, opts[:tick].to_i).each_with_index do |l, i|
+          row_lines(row, name, selected, width, now, view.tick).each_with_index do |l, i|
             lines << l
             items << ((i.zero? && row.selectable?) ? Item.new(:row, row, name) : nil)
           end
@@ -336,7 +358,8 @@ module ClaudeInbox
             state_badge(s) + @p.dim(" · #{where} · #{age}")
           else
             age = row.state_since ? @p.dim(" · " + Text.age(now.to_i - row.state_since.to_i)) : ""
-            state_badge(s) + age
+            remote = s.remote_control? ? @theme.blue(" ⇅") : ""
+            state_badge(s) + remote + age
           end
         end
       pr = pr_badge(s, section)
@@ -387,12 +410,12 @@ module ClaudeInbox
 
     # ----- peek ---------------------------------------------------------------
 
-    def peek_pane(lines, title, subtitle, width, height)
-      bar = Text.pad(" " + (title || ""), width)
+    def peek_pane(peek, width, height)
+      bar = Text.pad(" " + (peek.title || ""), width)
       out = [@p.inverse(bar)]
-      out << Text.pad(" " + @p.dim(subtitle.to_s), width) if subtitle
+      out << Text.pad(" " + @p.dim(peek.subtitle.to_s), width) if peek.subtitle
       body_h = height - out.size
-      wrapped = lines.flat_map { |l| Text.wrap(l, width - 1) }
+      wrapped = peek.lines.flat_map { |l| Text.wrap(l, width - 1) }
       wrapped.last(body_h).each { |l| out << Text.pad(" " + l, width) }
       out
     end
@@ -427,11 +450,10 @@ module ClaudeInbox
       @prev = []
     end
 
-    def paint(lines, force: false)
+    def paint(lines)
       buf = +""
-      buf << @cursor.clear_screen if force
       lines.each_with_index do |line, i|
-        next if !force && @prev[i] == line
+        next if @prev[i] == line
         buf << @cursor.move_to(0, i) << line
       end
       if @prev.size > lines.size

data/lib/claude_inbox/session.rb

@@ -10,14 +10,14 @@ module ClaudeInbox
   # move under it.
   Session = Data.define(
     :id, :cwd, :kind, :started_at, :session_id, :name,
-    :state, :pid, :status, :waiting_for, :origin, :prs, :job_state
+    :state, :pid, :status, :waiting_for, :origin, :prs, :job_state, :bridge_id
   ) do
     # Every member is optional so the parser and the specs name only what they
     # have; prs is [] rather than nil so nobody asks whether PullRequests has run.
     def initialize(id: nil, cwd: nil, kind: nil, started_at: nil, session_id: nil, name: nil,
-      state: nil, pid: nil, status: nil, waiting_for: nil, origin: nil, prs: nil, job_state: nil)
+      state: nil, pid: nil, status: nil, waiting_for: nil, origin: nil, prs: nil, job_state: nil, bridge_id: nil)
       super(id: id, cwd: cwd, kind: kind, started_at: started_at, session_id: session_id, name: name,
-            state: state, pid: pid, status: status, waiting_for: waiting_for, origin: origin, prs: prs || [], job_state: job_state)
+            state: state, pid: pid, status: status, waiting_for: waiting_for, origin: origin, prs: prs || [], job_state: job_state, bridge_id: bridge_id)
     end
 
     def self.from_hash(h)
@@ -59,6 +59,17 @@ module ClaudeInbox
 
     def terminal? = interactive? && !remote? && !unattended?
 
+    # Where claude.ai/code shows this session. Every background session
+    # registers a bridge and records it in the job file; a worker a `claude
+    # remote-control` server spawned carries it on its command line.
+    def remote_url
+      bridge = bridge_id || job_state&.bridge_id
+      bridge && "https://claude.ai/code/session_#{bridge.delete_prefix("cse_")}"
+    end
+
+    # Driven from claude.ai/code as well as from here, not only followed there.
+    def remote_control? = remote? || job_state&.remote_control? == true
+
     # Selection handle: short id for background sessions, the UUID otherwise.
     def key = id || session_id
 
@@ -69,6 +80,9 @@ module ClaudeInbox
     # From `/color`; interactive sessions have no job file, so never one.
     def color = job_state&.color
 
+    # The prompt this session was started with.
+    def intent = job_state&.intent
+
     # The session's own one-line account of where it is, the same line
     # `claude agents` prints under a row: what it needs while blocked, what
     # it produced once done, otherwise its status line. Nil without a job

data/lib/claude_inbox/sessions.rb

@@ -10,8 +10,8 @@ module ClaudeInbox
   module Sessions
     module_function
 
-    def load(client:, jobs_dir:, pull_requests:, overrides:)
-      sessions = JobState.enrich(client.list, jobs_dir: jobs_dir)
+    def load(client:, pull_requests:, overrides:)
+      sessions = JobState.enrich(client.list, jobs_dir: client.jobs_dir)
       pull_requests.enrich(sessions, overrides)
     end
   end

data/lib/claude_inbox/slash_commands.rb

@@ -26,8 +26,8 @@ module ClaudeInbox
     def list(cwd:, home: Dir.home)
       found = {}
       add = ->(cmd) { found[cmd.name] ||= cmd }
-      local(File.join(cwd, ".claude"), "project").each(&add)
-      local(File.join(home, ".claude"), "user").each(&add)
+      from_dir(File.join(cwd, ".claude"), "project").each(&add)
+      from_dir(File.join(home, ".claude"), "user").each(&add)
       plugins(home).each(&add)
       synced(home).each(&add)
       found.values.sort_by(&:name)
@@ -39,8 +39,9 @@ module ClaudeInbox
       starts + rest.select { |c| c.name.downcase.include?(q) }
     end
 
-    def local(dir, source)
-      skills(File.join(dir, "skills"), source) + commands(File.join(dir, "commands"), source)
+    def from_dir(dir, source, prefix: nil)
+      skills(File.join(dir, "skills"), source, prefix:) +
+        commands(File.join(dir, "commands"), source, prefix:)
     end
 
     def skills(dir, source, prefix: nil)
@@ -70,8 +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|
-          skills(File.join(root, "skills"), "plugin", prefix: plugin) +
-            commands(File.join(root, "commands"), "plugin", prefix: plugin)
+          from_dir(root, "plugin", prefix: plugin)
         end
       end
     end

data/lib/claude_inbox/store/row.rb

@@ -27,9 +27,11 @@ module ClaudeInbox
 
       def reap_failed_at = entry&.reap_failed_at
 
+      # Names get shortened and forgotten, so the filter also reads what the
+      # session was asked to do and what it says it is doing now.
       def matches?(query)
         q = query.downcase
-        label.downcase.include?(q) || session.cwd.to_s.downcase.include?(q)
+        [label, session.cwd, session.intent, session.summary].any? { |field| field.to_s.downcase.include?(q) }
       end
 
       # A session already blocked when you snoozed it stays snoozed; one that
@@ -89,10 +91,8 @@ module ClaudeInbox
         if session.terminal? then session.needs_you? ? :needs_you : :active
         elsif pinned? then :pinned
         elsif snoozed?(now) then :snoozed
-        elsif !revived? && hand_settled? then :settled
         elsif !revived? && settled? then :settled # a resolved PR outranks Needs You
         elsif session.needs_you? then acknowledged? ? :active : :needs_you
-        elsif session.finished? then :active
         else :active
         end
       end

data/lib/claude_inbox/store.rb

@@ -35,10 +35,15 @@ module ClaudeInbox
       out
     end
 
+    def self.row_for(session, entries)
+      hash = session.key && entries[session.key]
+      Row.new(session: session, entry: hash && Entry.new(hash))
+    end
+
     def self.sectionize(sessions, entries, now)
       sec = Sections.new(pinned: [], needs_you: [], active: [], snoozed: [], settled: [])
       sessions.each do |s|
-        row = Row.new(session: s, entry: s.key && entries[s.key] && Entry.new(entries[s.key]))
+        row = row_for(s, entries)
         sec[row.section(now)] << row
       end
       sec.pinned.sort_by! { |r| -(r.pinned_at || 0) }
@@ -108,7 +113,11 @@ module ClaudeInbox
       @mutex.synchronize { @entries.transform_values { |e| Entry.new(e).pr }.select { |_, url| url } }
     end
 
-    def row(session) = Row.new(session: session, entry: session.key && entry(session.key)&.then { |e| Entry.new(e) })
+    # A copy, not the live entry: the reaper decides a deletion on this row
+    # while the UI thread may be editing that entry in place.
+    def row(session)
+      @mutex.synchronize { self.class.row_for(session, {session.key => @entries[session.key]&.dup}) }
+    end
 
     # The raw hash, for the specs; nothing in lib/ reads it.
     def entry(id) = @mutex.synchronize { @entries[id]&.dup }

data/lib/claude_inbox/subprocess.rb

@@ -37,8 +37,9 @@ module ClaudeInbox
         ready, = IO.select(readers)
         ready.each do |io|
           chunk = io.read_nonblock(65_536, exception: false)
-          if chunk.nil? || chunk == :wait_readable
-            next unless chunk.nil?
+          case chunk
+          when :wait_readable then next
+          when nil
             readers.delete(io)
             io.close
           else

data/lib/claude_inbox/text.rb

@@ -61,13 +61,8 @@ module ClaudeInbox
     end
 
     # Greedy word wrap on display width. Words wider than `w` are split.
-    def wrap(s, w) = segments(s, w).map(&:rstrip)
-
-    # Word wrap that keeps every character, so joining the segments back
-    # together returns the original string. An editor needs that: `wrap`
-    # drops the space you just typed, and with it the cursor's place.
-    def segments(s, w)
-      return [s] if w <= 0 || width(s) <= w
+    def wrap(s, w)
+      return [s.rstrip] if w <= 0 || width(s) <= w
       lines = []
       line = +""
       s.split(/(?<= )/).each do |word|
@@ -76,13 +71,14 @@ module ClaudeInbox
           line = +""
         end
         while width(word) > w
-          lines << take(word, w)
-          word = word[take(word, w).size..]
+          head = take(word, w)
+          lines << head
+          word = word[head.size..]
         end
         line << word
       end
       lines << line unless line.empty?
-      lines
+      lines.map(&:rstrip)
     end
 
     # "45s", "12m", "3h", "2d"

data/lib/claude_inbox/text_buffer.rb

@@ -158,8 +158,9 @@ module ClaudeInbox
       rows
     end
 
-    # Text.segments on cells: a chip is one cell however wide its label, so
-    # the wrap has to measure cells rather than a joined string.
+    # Text.wrap on cells, keeping the trailing spaces the cursor may sit on:
+    # a chip is one cell however wide its label, so the wrap has to measure
+    # cells rather than a joined string.
     def segments(cells, width)
       return [cells] if width_of(cells) <= width
       words = cells.slice_when { |c, _| c == " " }.to_a