claude-inbox 0.7.1 → 0.9.0

data/lib/claude_inbox/notifier_app.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "subprocess"
+
+module ClaudeInbox
+  # A copy of Homebrew's terminal-notifier.app under our own bundle id and
+  # the web app's icon, since macOS draws a notification's icon from the
+  # bundle that sends it and offers no way to override it.
+  class NotifierApp
+    DEFAULT_PATH = File.join(Dir.home, ".config", "claude-inbox", "notifier.app")
+    ID = "dev.claude-inbox.notifier"
+    # Both drawn from remote/icon.svg; the .icns through iconutil, from a
+    # 16-1024px iconset of rsvg-convert renders.
+    ICNS = File.join(__dir__, "remote", "icon.icns")
+    PNG = File.join(__dir__, "remote", "icon.png")
+    # Plain terminal-notifier carries the icon as a thumbnail instead.
+    FALLBACK = ["terminal-notifier", "-contentImage", PNG].freeze
+
+    def self.disabled = new(path: nil)
+
+    def initialize(path: DEFAULT_PATH, run: Subprocess.method(:capture))
+      @path = path
+      @run = run
+    end
+
+    # Builds the copy when terminal-notifier's own app is new to us, and
+    # sends one notification through `open`: macOS asks permission only of
+    # an app LaunchServices started, never of its binary run from a shell.
+    def prepare
+      return unless @path && (app = source) && !current?(app)
+      return unless build(app)
+      @run.call("open", "-n", @path, "--args", "-title", "claude-inbox", "-message", "Notifications active.")
+    end
+
+    # The argv that sends one notification, short of its own flags.
+    def command = (@path && current?(source)) ? [File.join(@path, "Contents", "MacOS", "terminal-notifier")] : FALLBACK
+
+    private
+
+    def source
+      return @source if defined?(@source)
+      r = @run.call("brew", "--prefix", "terminal-notifier")
+      app = File.join(r.out.strip, "terminal-notifier.app") if r.success?
+      @source = (app && File.directory?(app)) ? File.realpath(app) : nil
+    end
+
+    # The copy names the app it came from, whose Cellar path carries the
+    # version, so an upgrade rebuilds it.
+    def current?(app)
+      app && File.read(stamp(@path)) == app
+    rescue SystemCallError
+      false
+    end
+
+    def stamp(bundle) = File.join(bundle, "Contents", "Resources", "source")
+
+    # Built aside and moved into place, so `command` never sees half a copy.
+    def build(app)
+      tmp = "#{@path}.tmp"
+      FileUtils.rm_rf(tmp)
+      FileUtils.mkdir_p(File.dirname(tmp))
+      FileUtils.cp_r(app, tmp)
+      FileUtils.cp(ICNS, File.join(tmp, "Contents", "Resources", "claude-inbox.icns"))
+      File.write(stamp(tmp), app)
+      plist = File.join(tmp, "Contents", "Info.plist")
+      steps = [
+        ["plutil", "-replace", "CFBundleIdentifier", "-string", ID, plist],
+        ["plutil", "-replace", "CFBundleName", "-string", "claude-inbox", plist],
+        ["plutil", "-replace", "CFBundleIconFile", "-string", "claude-inbox", plist],
+        ["codesign", "--force", "--sign", "-", tmp]
+      ]
+      unless steps.all? { |argv| @run.call(*argv).success? }
+        FileUtils.rm_rf(tmp)
+        return false
+      end
+      FileUtils.rm_rf(@path)
+      File.rename(tmp, @path)
+      true
+    end
+  end
+end

data/lib/claude_inbox/poller.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "notifier"
 require_relative "sessions"
 
 module ClaudeInbox
@@ -7,16 +8,16 @@ module ClaudeInbox
   # seconds and on demand, puts what it finds in the store and the snapshot,
   # and tells App over the shared queue: [:sessions] after each
   # hand-over, [:error, msg] when a poll fails, [:notice, text] when the
-  # reaper took something. Between polls it applies what another front end
-  # asked for. Nothing here touches App's state directly; the queue is the
-  # whole of the interface. One worker runs every poll, so two can never
-  # overlap and publish the list out of order.
+  # reaper took something or terminal-notifier is missing. Between polls it
+  # applies what another front end asked for. Nothing here touches App's
+  # state directly; the queue is the whole of the interface. One worker runs
+  # every poll, so two can never overlap and publish the list out of order.
   class Poller
     INTERVAL = 4
     ACTIONS_INTERVAL = 0.5
 
     def initialize(client:, store:, pull_requests:, reaper:, queue:, snapshot:, actions:,
-      interval: INTERVAL, clock: -> { Time.now })
+      notifier: Notifier.disabled, interval: INTERVAL, clock: -> { Time.now })
       @client = client
       @clock = clock
       @store = store
@@ -25,6 +26,7 @@ module ClaudeInbox
       @queue = queue
       @snapshot = snapshot
       @actions = actions
+      @notifier = notifier
       @interval = interval
       @wake = Queue.new
     end
@@ -77,9 +79,15 @@ module ClaudeInbox
 
     private
 
+    # The notifier compares the sections from just before the hand-over, so
+    # a row you woke or unpinned yourself since the last poll says nothing.
     def publish(sessions)
+      now = @clock.call
+      before = @store.sections(now)
       @store.update(sessions)
-      write_snapshot
+      after = @store.sections(now)
+      @snapshot.write(after, now)
+      @notifier.deliver(before, after) { |msg| @queue << [:notice, msg] }
       @queue << [:sessions]
     end
 

data/lib/claude_inbox/pull_requests.rb

@@ -6,13 +6,31 @@ require_relative "records"
 require_relative "subprocess"
 
 module ClaudeInbox
+  # What is wrong with an open PR, in the words its badge and the picker
+  # use. CLEAN and unknown say nothing.
+  PR_TROUBLE = {"FAILING" => "✗ checks", "CHANGES_REQUESTED" => "changes requested", "CONFLICTING" => "conflicts"}.freeze
+
   # A pull request tied to a session. `state` uses GitHub's vocabulary plus
   # DRAFT, the same as Claude Code's own cache: OPEN, DRAFT, MERGED, CLOSED,
   # or nil when nothing has told us yet. `resolved_at` is when it was merged
-  # or closed, in epoch seconds, once gh has said.
-  PullRequest = Struct.new(:number, :url, :state, :resolved_at) do
+  # or closed, in epoch seconds, once gh has said. `health` is what gh last
+  # said is wrong with an open PR: FAILING (a check), CHANGES_REQUESTED or
+  # CONFLICTING; CLEAN when nothing is, nil when nothing has said. Claude
+  # Code's cache knows nothing of it, and a resolved PR has none. `title`
+  # is whatever gh or the cache last called it, nil until one has.
+  PullRequest = Struct.new(:number, :url, :state, :resolved_at, :health, :title) do
     def short = number ? "##{number}" : url.to_s.sub(%r{\Ahttps?://(www\.)?}, "")
 
+    def repo = url.to_s[%r{\Ahttps://github\.com/([^/\s]+/[^/\s]+)/pull/\d+}, 1]
+
+    def qualified = (number && repo) ? "#{repo}##{number}" : short
+
+    def trouble = PR_TROUBLE[health]
+
+    # Failing checks or requested changes want you back; a conflict only
+    # waits on whoever rebases.
+    def needs_you? = %w[FAILING CHANGES_REQUESTED].include?(health)
+
     def merged? = state == "MERGED"
 
     def closed? = state == "CLOSED"
@@ -56,6 +74,7 @@ module ClaudeInbox
   # open PR, and the poller calls it after the list has already gone up.
   class PullRequests
     REFRESH_AFTER = 60
+    FAILED_CHECKS = %w[FAILURE ERROR TIMED_OUT CANCELLED ACTION_REQUIRED STARTUP_FAILURE].freeze
 
     CACHE_PATH = File.join(Dir.home, ".claude", "gh-pr-status-cache.json")
     RESOLVED_PATH = File.join(Dir.home, ".config", "claude-inbox", "prs.json")
@@ -114,11 +133,27 @@ module ClaudeInbox
       h = JSON.parse(json)
       state = (h["state"] == "OPEN" && h["isDraft"]) ? "DRAFT" : h["state"]
       resolved_at = h["closedAt"] && Time.iso8601(h["closedAt"]).to_i
-      PullRequest.new(number: h["number"], url: h["url"] || url, state: state, resolved_at: resolved_at)
+      PullRequest.new(number: h["number"], url: h["url"] || url, state: state, resolved_at: resolved_at,
+        health: (health(h) if h["state"] == "OPEN"), title: h["title"])
     rescue JSON::ParserError, ArgumentError
       nil
     end
 
+    # A check run reports a `conclusion`, a commit status a `state`; the
+    # rollup mixes both. It also keeps every run of a check on the head
+    # commit, so a run a newer one cancelled or replaced still shows its
+    # verdict there; only the latest run of each check counts.
+    def self.health(h)
+      checks = (h["statusCheckRollup"] || [])
+        .group_by { |c| [c["workflowName"], c["name"] || c["context"]] }
+        .map { |_, runs| runs.max_by { |c| c["startedAt"].to_s } }
+      if checks.any? { |c| FAILED_CHECKS.include?(c["conclusion"] || c["state"]) } then "FAILING"
+      elsif h["reviewDecision"] == "CHANGES_REQUESTED" then "CHANGES_REQUESTED"
+      elsif h["mergeable"] == "CONFLICTING" then "CONFLICTING"
+      else "CLEAN"
+      end
+    end
+
     # Only an https://github.com/<owner>/<repo>/pull/<n> link makes sense here.
     def self.valid_url?(url)
       url.to_s.match?(%r{\Ahttps://github\.com/[^/\s]+/[^/\s]+/pull/\d+/?\z})
@@ -139,7 +174,7 @@ module ClaudeInbox
       number = url[%r{/pull/(\d+)}, 1]&.to_i
       cached = resolved[url] || claude_cache[url]
       PullRequest.new(number: cached&.dig("number") || number, url: url, state: cached&.dig("state"),
-        resolved_at: cached&.dig("resolved_at"))
+        resolved_at: cached&.dig("resolved_at"), title: cached&.dig("title"))
     end
 
     # Same shape as Claude Code's cache, so `seed` reads both alike.
@@ -153,13 +188,15 @@ module ClaudeInbox
 
     # Under @mutex.
     def remember(pr)
-      resolved[pr.url] = {"number" => pr.number, "state" => pr.state, "resolved_at" => pr.resolved_at}
+      resolved[pr.url] = {"number" => pr.number, "state" => pr.state, "resolved_at" => pr.resolved_at,
+        "title" => pr.title}
       return unless @resolved_path
       Records.save(@resolved_path, resolved)
     end
 
     def fetch(url)
-      r = Subprocess.capture(@gh, "pr", "view", url, "--json", "number,state,isDraft,url,closedAt")
+      r = Subprocess.capture(@gh, "pr", "view", url, "--json",
+        "number,state,isDraft,url,closedAt,statusCheckRollup,reviewDecision,mergeable,title")
       r.success? ? self.class.parse(url, r.out) : nil
     rescue SystemCallError
       nil

data/lib/claude_inbox/renderer.rb

@@ -39,6 +39,10 @@ module ClaudeInbox
     # the table isn't named on the badge at all.
     PR_HUES = {"OPEN" => :green, "DRAFT" => nil, "MERGED" => :purple, "CLOSED" => :red}.freeze
 
+    # The hue of PR_TROUBLE after a badge. Red for what puts the row in
+    # Needs You; a conflict dims, since it waits on a rebase, not on you.
+    PR_TROUBLE_HUES = {"FAILING" => :red, "CHANGES_REQUESTED" => :red}.freeze
+
     SPINNER = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
 
     # The first poll usually lands inside a second. Past LOADING_QUIET the
@@ -172,7 +176,7 @@ module ClaudeInbox
         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, listening_chip(listening)].compact.join(compact ? "  " : @p.dim("  ·  "))
     end
@@ -293,15 +297,20 @@ module ClaudeInbox
 
     def fold_toggle_line(name, count, selected, width)
       sel = selected == name
-      marker = sel ? @theme.cyan_bold("▶") : " "
+      marker = sel ? @theme.yellow_bold("▶") : " "
       text = @p.dim("… #{count} #{SECTION_TITLES[name].downcase}") + (sel ? @p.dim("   ⏎ or zo to expand") : "")
       Text.pad(" #{marker} " + text, width)
     end
 
     def row_lines(row, section, selected, width, now, tick)
       s = row.session
+      live = %i[pinned needs_you active].include?(section)
       sel = row.selectable? && selected == row.key
-      marker = sel ? @theme.cyan_bold("▶") : " "
+      quiet = section == :settled || (live && row.read?)
+      unread = live && row.unread?
+      # A terminal cannot be attached to, so it is never read: while it waits on you it keeps its dot.
+      alert = live && s.needs_you? && (unread || !s.actionable?)
+      marker = marker_for(sel, unread, alert)
       glyph = glyph_for(s, section, tick)
       meta = meta_for(row, section, now)
 
@@ -311,14 +320,14 @@ module ClaudeInbox
       # so the row can never exceed `width` and fall into Text.pad's blind
       # tail-chop (which used to land mid-project-name with no ellipsis).
       project_text = Text.truncate(s.project, [width - chrome, 0].max)
-      project = (section == :settled) ? @p.dim(project_text) : @theme.cyan(project_text)
+      project = quiet ? @p.dim(project_text) : @theme.cyan(project_text)
 
       label_w = [width - chrome - Text.width(project_text), 0].max
       label = Text.truncate(row.label, label_w)
-      label = style_label(label, row, section, sel)
+      label = style_label(label, row, quiet, sel || (live && row.unread?))
       first = " #{marker} #{glyph} " + Text.pad(label, label_w) + "  " + meta + "  " + project + " "
 
-      return [Text.pad(first, width)] unless %i[pinned needs_you active].include?(section)
+      return [Text.pad(first, width)] unless live
 
       # The session's own line when it has one; the path is what is left to
       # say about a terminal, which has no job file.
@@ -326,15 +335,29 @@ module ClaudeInbox
       [Text.pad(first, width), Text.pad(detail, width)]
     end
 
+    # The caret takes the column. Otherwise one filled dot asks for a look:
+    # red while the row needs you, blue when it only finished. Read, it
+    # clears, and the meta still says needs you.
+    def marker_for(sel, unread, alert)
+      if sel then @theme.yellow_bold("▶")
+      elsif alert then @theme.red_bold("●")
+      elsif unread then @theme.blue("●")
+      else " "
+      end
+    end
+
     # The label is the one part of a row you own: `/color` tints it, and
     # nothing else on the line. Glyph, badge and PR keep the state's colors,
     # so no color you pick can make a blocked session stop looking blocked.
-    # Settled stays dim — the section is meant to be quiet.
-    def style_label(label, row, section, sel)
-      return @p.dim(label) if section == :settled
+    # A quiet row (settled, or finished and read) is dim, unless it has a
+    # tint: faint blue or pink is unreadable on a dark background, and the
+    # rest of the row already dims. Bold marks an unread row, as a mail
+    # client does, and the selected one under its caret.
+    def style_label(label, row, quiet, bold)
       styled =
-        if row.alias_name then sel ? @p.bold.italic(label) : @p.italic(label)
-        elsif sel then @p.bold(label)
+        if quiet then Palette::SEQUENCES.key?(row.session.color) ? label : @p.dim(label)
+        elsif row.alias_name then bold ? @p.bold.italic(label) : @p.italic(label)
+        elsif bold then @p.bold(label)
         else label
         end
       @palette.paint(styled, row.session.color)
@@ -344,12 +367,12 @@ module ClaudeInbox
       return @theme.purple("z") if section == :snoozed
       return @p.dim("◦") if section == :settled
       case s.effective_state
-      when "blocked" then @theme.red_bold("●")
+      when "blocked" then @theme.red_bold("?")
       when "failed" then @theme.red_bold("✗")
       when "working" then s.waiting_on_work? ? @theme.yellow("◌") : @theme.yellow(SPINNER[tick % SPINNER.size])
       when "done" then @theme.green("✓")
       when "stopped" then @p.dim("■")
-      else @p.dim("?")
+      else @p.dim("·")
       end
     end
 
@@ -376,13 +399,20 @@ module ClaudeInbox
       pr ? base + @p.dim(" · ") + pr : base
     end
 
-    # "#885 open". Only the first PR is shown.
+    # "#885 open", or "#885 open · ✗ checks" when something is wrong. The
+    # headline PR is shown, with a count of the rest.
     def pr_badge(s, section)
       pr = s.pr
       return nil unless pr
+      more = (s.prs.size > 1) ? @p.dim(" · +#{s.prs.size - 1}") : ""
+      pr_state_badge(pr, section) + more
+    end
+
+    def pr_state_badge(pr, section)
       return @p.dim("#{pr.short} #{pr.state&.downcase}".strip) if section == :settled
       return @p.dim(pr.short) unless PR_HUES.key?(pr.state)
-      tint(PR_HUES[pr.state], "#{pr.short} #{pr.state.downcase}")
+      badge = tint(PR_HUES[pr.state], "#{pr.short} #{pr.state.downcase}")
+      pr.trouble ? badge + @p.dim(" · ") + tint(PR_TROUBLE_HUES[pr.health], pr.trouble) : badge
     end
 
     def state_badge(s)

data/lib/claude_inbox/session.rb

@@ -99,6 +99,19 @@ module ClaudeInbox
 
     def project = cwd ? File.basename(cwd) : ""
 
-    def pr = prs.first
+    # The PR you would act on. One resolved before the session began was
+    # only mentioned (as Row#settled? judges), so it loses to any live one.
+    def pr = prs.each_with_index.min_by { |pr, i| [headline_rank(pr), i] }&.first
+
+    private
+
+    def headline_rank(pr)
+      if !pr.known? || pr.resolved_before?(created_at) then 4
+      elsif pr.needs_you? then 0
+      elsif pr.health == "CONFLICTING" then 1
+      elsif !pr.resolved? then 2
+      else 3
+      end
+    end
   end
 end

data/lib/claude_inbox/snapshot.rb

@@ -44,7 +44,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, "line" => s.summary, "wake_at" => row.wake_at, "remote" => s.remote_url, "color" => s.color,
+        "waiting" => s.waiting_on_work? || nil, "unread" => row.unread? || nil, "line" => s.summary, "wake_at" => row.wake_at, "remote" => s.remote_url, "color" => s.color,
         "pr" => pr && {"short" => pr.short, "state" => pr.state&.downcase, "url" => pr.url}
       }.compact
     end

data/lib/claude_inbox/snooze_time.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "date"
+
+module ClaudeInbox
+  # The wake time a typed snooze means, as an epoch, or nil for text it does
+  # not read. Takes a duration (`45m`, `2h`, `3d`), a clock time (`17:00`,
+  # `5pm`) for the next such time, a weekday (`fri`, `friday`) for that day
+  # at 9am, `tomorrow`, or `tonight`/`evening` for the next 6pm. A weekday
+  # or `tomorrow` may carry a time after it (`fri 5pm`).
+  module SnoozeTime
+    UNITS = {"m" => 60, "min" => 60, "mins" => 60, "minute" => 60, "minutes" => 60,
+             "h" => 3600, "hr" => 3600, "hrs" => 3600, "hour" => 3600, "hours" => 3600,
+             "d" => 86_400, "day" => 86_400, "days" => 86_400}.freeze
+    WEEKDAYS = {"sun" => 0, "mon" => 1, "tue" => 2, "wed" => 3, "thu" => 4, "fri" => 5, "sat" => 6}.freeze
+    DURATION = /\A(\d+)\s*(#{UNITS.keys.join("|")})\z/
+    WEEKDAY = /\A(#{WEEKDAYS.keys.join("|")})[a-z]*\z/
+    CLOCK = /\A(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\z/
+    MORNING = [9, 0].freeze
+    EVENING = [18, 0].freeze
+
+    def self.parse(text, now)
+      text = text.to_s.strip.downcase
+      if (m = DURATION.match(text))
+        return m[1].to_i.positive? ? now.to_i + m[1].to_i * UNITS[m[2]] : nil
+      end
+      head, rest = text.split(/\s+/, 2)
+      case head
+      when nil then nil
+      when "tonight", "evening" then rest.nil? ? next_at(now, EVENING) : nil
+      when "tomorrow" then (hm = rest ? clock(rest) : MORNING) && at(now, 1, hm)
+      when WEEKDAY then (hm = rest ? clock(rest) : MORNING) && weekday(now, WEEKDAYS[head[0, 3]], hm)
+      else (hm = clock(text)) && next_at(now, hm)
+      end
+    end
+
+    # [hour, minute] for `17:00`, `5pm` or `5:30pm`; a bare number is not a time.
+    def self.clock(text)
+      m = CLOCK.match(text)
+      return nil if m.nil? || (m[2].nil? && m[3].nil?)
+      hour, minute = m[1].to_i, m[2].to_i
+      return nil if minute > 59
+      if m[3]
+        return nil unless (1..12).cover?(hour)
+        hour = hour % 12 + ((m[3] == "pm") ? 12 : 0)
+      elsif hour > 23
+        return nil
+      end
+      [hour, minute]
+    end
+
+    # That day at `hm`, or a week on when it has already passed.
+    def self.weekday(now, wday, hm)
+      t = at(now, (wday - now.wday) % 7, hm)
+      (t > now.to_i) ? t : t + 7 * 86_400
+    end
+
+    # Today at `hm`, or tomorrow when it has already passed.
+    def self.next_at(now, hm)
+      t = at(now, 0, hm)
+      (t > now.to_i) ? t : at(now, 1, hm)
+    end
+
+    def self.at(now, days, (hour, minute))
+      day = now.to_date + days
+      Time.new(day.year, day.month, day.day, hour, minute, 0, now.utc_offset).to_i
+    end
+  end
+end

data/lib/claude_inbox/store/entry.rb

@@ -20,8 +20,10 @@ module ClaudeInbox
         (hash ? new(hash) : first_seen(session, now)).observe(session, now)
       end
 
+      # An Integer choice is the wake time itself, as typed after `5`.
       def self.snooze_until(choice, now)
         case choice
+        when Integer then choice
         when :m15 then now.to_i + 15 * 60
         when :h1 then now.to_i + 3600
         when :tomorrow_9am
@@ -64,11 +66,17 @@ module ClaudeInbox
 
       def acknowledged_at = @h["acknowledged_at"]
 
+      # When you last attached. Never cleared, unlike `acknowledged_at`.
+      def last_visited_at = @h["last_visited_at"]
+
       def revived_at = @h["revived_at"]
 
       # When `claude rm` last refused this session, so the Reaper backs off.
       def reap_failed_at = @h["reap_failed_at"]
 
+      # What was last wrong with the PR, while something is.
+      def pr_health = @h["pr_health"]
+
       def stale?(now) = last_seen && now.to_i - last_seen > PRUNE_AFTER
 
       def observe(session, now)
@@ -77,6 +85,14 @@ module ClaudeInbox
           @h["last_state"] = session.effective_state
           @h["state_since"] = now_i
         end
+        # Trouble on the PR is a state change too, so an attach answers it
+        # like a blocked state and it sorts to the top of Needs You. Only the
+        # trouble is kept, and a PR gh has not described leaves it as it was.
+        health = session.pr&.health
+        if health && health != (pr_health || "CLEAN")
+          (health == "CLEAN") ? @h.delete("pr_health") : @h["pr_health"] = health
+          @h["state_since"] = now_i
+        end
         @h["last_seen"] = now_i
         row = Row.new(session: session, entry: self)
         @h.delete("wake_at") if row.woken?(now_i)
@@ -109,8 +125,12 @@ module ClaudeInbox
         @h.delete("revived_at")
       end
 
+      # One attach, two clocks: `acknowledged_at` lapses with the state and
+      # moves the row between sections; `last_visited_at` keeps, so a row
+      # that finishes after you looked reads as unread until you look again.
       def acknowledge(now)
         @h["acknowledged_at"] = now.to_i
+        @h["last_visited_at"] = now.to_i
       end
 
       def toggle_pin(now)

data/lib/claude_inbox/store/row.rb

@@ -55,12 +55,33 @@ module ClaudeInbox
         entry&.acknowledged_at && entry.state_since.to_i <= entry.acknowledged_at.to_i
       end
 
+      # Finished or needing you since you last attached. Only a session you
+      # can attach to counts, since nothing else ever clears the mark.
+      def unread?
+        return false unless session.actionable?
+        return false unless session.finished? || session.needs_you?
+        entry&.last_visited_at.nil? || entry.state_since.to_i > entry.last_visited_at.to_i
+      end
+
+      # A finished or blocked session you have attached to since: you have seen what it wants.
+      def read? = session.actionable? && (session.finished? || session.needs_you?) && !unread?
+
       # `u` overrides hand-settle and the PR rule alike, and holds until the
       # state actually changes rather than just for the next poll.
       def revived?
         entry&.revived_at && entry.state_since.to_i <= entry.revived_at.to_i
       end
 
+      # Failing checks or requested changes on the PR want you back the way
+      # a blocked session does, once the agent has stopped working on it.
+      # Only an open PR gh has described has a health, so the unknown and
+      # the long-resolved PRs `settled?` guards against never count here.
+      # Entry#observe treats a change of health as a state change, so
+      # attaching answers it until the health changes again.
+      def pr_needs_you?
+        session.effective_state != "working" && session.pr&.needs_you? == true
+      end
+
       # Resolved PRs settle a `blocked` row too: asking "anything need
       # changing?" leaves it blocked, and merging answers it. `failed` stays
       # in view even if its PR landed; a PR nobody knows the state of yet
@@ -94,7 +115,7 @@ module ClaudeInbox
         elsif pinned? then :pinned
         elsif snoozed?(now) then :snoozed
         elsif !revived? && settled? then :settled # a resolved PR outranks Needs You
-        elsif session.needs_you? then acknowledged? ? :active : :needs_you
+        elsif session.needs_you? || pr_needs_you? then acknowledged? ? :active : :needs_you
         else :active
         end
       end

data/lib/claude_inbox/store/sections.rb

@@ -6,10 +6,6 @@ module ClaudeInbox
     Sections = Struct.new(:pinned, :needs_you, :active, :snoozed, :settled) do
       def all = values.flatten(1)
 
-      def row(selection)
-        all.find { |r| r.key == selection.key } if selection&.row?
-      end
-
       def matching(query)
         return self if query.nil? || query.empty?
         self.class.new(**to_h.transform_values { |rows| rows.select { |r| r.matches?(query) } })

data/lib/claude_inbox/store.rb

@@ -162,7 +162,7 @@ module ClaudeInbox
         yield Entry.new(@entries[id] ||= Entry.blank(@clock.call).to_h)
         save
       end
-      @relay&.request(action, id, **detail) if !@writable && action
+      @relay&.request(action, id, **detail) unless @writable
     end
 
     def load

data/lib/claude_inbox/subprocess.rb

@@ -20,14 +20,18 @@ module ClaudeInbox
     # argv as exec and Process.spawn take it, with CHILD_ENV in place of ours.
     def command(*argv) = CHILD_ENV ? [CHILD_ENV, *argv, {unsetenv_others: true}] : argv
 
-    def capture(*argv, chdir: nil)
+    # `input` is written before any output is read, so it is for the few
+    # bytes a clipboard takes, not a stream.
+    def capture(*argv, chdir: nil, input: nil)
+      in_r, in_w = IO.pipe if input
       out_r, out_w = IO.pipe
       err_r, err_w = IO.pipe
       pid = fork do
         Process.setsid
-        $stdin.reopen(File::NULL)
+        $stdin.reopen(input ? in_r : File::NULL)
         $stdout.reopen(out_w)
         $stderr.reopen(err_w)
+        in_w&.close
         out_r.close
         err_r.close
         Dir.chdir(chdir) if chdir
@@ -38,6 +42,7 @@ module ClaudeInbox
       end
       out_w.close
       err_w.close
+      feed(in_r, in_w, input) if input
       out = +""
       err = +""
       readers = [out_r, err_r]
@@ -58,5 +63,15 @@ module ClaudeInbox
       _, status = Process.wait2(pid)
       Result.new(out, err, status)
     end
+
+    # A child that exits without reading closes the pipe under us.
+    def feed(reader, writer, input)
+      reader.close
+      writer.write(input)
+    rescue Errno::EPIPE
+      nil
+    ensure
+      writer.close
+    end
   end
 end

data/lib/claude_inbox/terminal.rb

@@ -98,9 +98,6 @@ module ClaudeInbox
 
     def paint(lines) = @painter.paint(lines)
 
-    # Repaint every row on the next frame.
-    def invalidate = @painter.invalidate
-
     private
 
     def measure

data/lib/claude_inbox.rb

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