claude-inbox 0.7.0 → 0.8.0

data/lib/claude_inbox/pull_requests.rb

@@ -9,10 +9,17 @@ module ClaudeInbox
   # 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.
+  PullRequest = Struct.new(:number, :url, :state, :resolved_at, :health) do
     def short = number ? "##{number}" : url.to_s.sub(%r{\Ahttps?://(www\.)?}, "")
 
+    # 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 +63,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 +122,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"))
     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})
@@ -159,7 +183,8 @@ module ClaudeInbox
     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")
       r.success? ? self.class.parse(url, r.out) : nil
     rescue SystemCallError
       nil

data/lib/claude_inbox/renderer.rb

@@ -39,6 +39,12 @@ module ClaudeInbox
     # the table isn't named on the badge at all.
     PR_HUES = {"OPEN" => :green, "DRAFT" => nil, "MERGED" => :purple, "CLOSED" => :red}.freeze
 
+    # What is wrong with an open PR, after its badge. Red for what puts the
+    # row in Needs You; a conflict dims, since it waits on a rebase, not on
+    # you. CLEAN and unknown say nothing.
+    PR_TROUBLE = {"FAILING" => [:red, "✗ checks"], "CHANGES_REQUESTED" => [:red, "changes requested"],
+                  "CONFLICTING" => [nil, "conflicts"]}.freeze
+
     SPINNER = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
 
     # The first poll usually lands inside a second. Past LOADING_QUIET the
@@ -172,7 +178,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 +299,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 +322,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 +337,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 +369,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 +401,16 @@ 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. Only
+    # the first PR is shown.
     def pr_badge(s, section)
       pr = s.pr
       return nil unless pr
       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}")
+      hue, trouble = PR_TROUBLE[pr.health]
+      trouble ? badge + @p.dim(" · ") + tint(hue, trouble) : badge
     end
 
     def state_badge(s)

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.0"
+  VERSION = "0.8.0"
 end

data/mod/hooks/register.tsx

@@ -35,6 +35,7 @@ export type SnapshotRow = {
   state?: string
   actionable?: boolean
   waiting?: boolean
+  unread?: boolean
   line?: string
   wake_at?: number | 'until_woken'
   remote?: string
@@ -51,7 +52,7 @@ type Action = { action: 'settle' | 'wake' | 'pin'; id: string } | { action: 'sno
 
 const ORDER: Section[] = ['pinned', 'needs_you', 'active', 'snoozed', 'settled']
 const TITLE: Record<Section, string> = { pinned: 'Pinned', needs_you: 'Needs you', active: 'Active', snoozed: 'Snoozed', settled: 'Settled' }
-const GLYPH: Record<string, string> = { blocked: '●', failed: '✗', working: '◐', idle: '◌', done: '✓', stopped: '✓' }
+const GLYPH: Record<string, string> = { blocked: '?', failed: '✗', working: '◐', idle: '◌', done: '✓', stopped: '✓' }
 const COLOR: Record<string, string> = { blocked: 'red', failed: 'red', working: 'green', idle: 'cyan' }
 const PR_COLOR: Record<string, string> = { open: 'green', draft: 'yellow', merged: 'magenta', closed: 'red' }
 // `/color`'s names as a label's background. A Button keeps the terminal's own ink, light on a dark
@@ -138,6 +139,7 @@ export function rowOf(section: Section, one: SnapshotRow): InboxRow {
     state: one.state ?? 'unknown',
     actionable: one.actionable === true,
     isWaiting: one.waiting === true,
+    isUnread: one.unread === true,
     line: one.line,
     wakeAt: one.wake_at,
     remote: one.remote,
@@ -456,11 +458,20 @@ export const register: Register = (on, options) => {
               }
               const one = item.row
               const isQuiet = isFold(one.section)
+              // A finished or blocked row you have attached to since dims, as the gem's Active section draws it,
+              // unless it is tinted: faint ink on a /color background is unreadable.
+              const isRead = !isQuiet && one.actionable && ['done', 'stopped', 'blocked', 'failed'].includes(one.state) && !one.isUnread
+              // One dot asks for a look: red while the row needs you, blue when it only finished. A terminal
+              // cannot be attached to, so it is never read and keeps its dot while it waits.
+              const needsYou = one.state === 'blocked' || one.state === 'failed'
+              const alert = !isQuiet && needsYou && (one.isUnread || !one.actionable)
+              const dot = alert || (one.isUnread && !isQuiet)
+              const text = one.wakeAt !== undefined ? `${one.label} · ${wakeLabel(one.wakeAt)}` : one.label
               const tint = one.color ? TINT[one.color] : undefined
               return (
                 <Box key={viewKey(item)} flexDirection="column">
                   <Box>
-                    <Text color={isHere ? 'yellow' : undefined}>{isHere ? '› ' : '  '}</Text>
+                    <Text color={isHere ? 'yellow' : alert ? 'red' : 'blue'}>{isHere ? '› ' : dot ? '● ' : '  '}</Text>
                     <Text color={COLOR[one.state]} dimColor={isQuiet || one.state === 'done'}>
                       {GLYPH[one.state] ?? '·'}{' '}
                     </Text>
@@ -470,11 +481,14 @@ export const register: Register = (on, options) => {
                       <Button
                         key={itemKey(item)}
                         plain
-                        dimColor={isQuiet && !isHere}
-                        label={one.wakeAt !== undefined ? `${one.label} · ${wakeLabel(one.wakeAt)}` : one.label}
+                        dimColor={(isQuiet || isRead) && !isHere && tint === undefined}
+                        label={text}
                         onPress={enter(item)}
                         autoFocus={isHere || undefined}
-                      />
+                      >
+                        {/* An unread row is bold, as a mail client marks one; a Button has no weight of its own. */}
+                        {one.isUnread && !isQuiet ? <Text bold>{text}</Text> : text}
+                      </Button>
                     </Box>
                     {/* The label gives up its cells to the PR chip, which would otherwise wrap under it. */}
                     {one.pr ? (

data/mod/tests/contract.test.tsx

@@ -19,4 +19,5 @@ test("the rows the pane reads are the ones the gem's Snapshot writes", () => {
   ])
   expect(rows[1]?.pr).toEqual({ short: '#7', state: 'open', url: 'https://github.com/o/r/pull/7' })
   expect(rows[0]?.isWaiting).toBe(false)
+  expect(rows.map(row => row.isUnread)).toEqual([true, false, true])
 })

data/mod/tests/pane.test.tsx

@@ -13,6 +13,7 @@ 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 },
+  { section: 'active', id: 'd4', label: 'finished unseen', state: 'done', actionable: true, isUnread: true },
   { section: 'settled', id: 'c3', label: 'put away', state: 'done', actionable: true },
 ]
 
@@ -97,9 +98,12 @@ test("rows sit under the gem's sections, Settled folded until za opens it", asyn
   for (const surface of ['terminal', 'desktop'] as const) {
     const ui = await $.ui.mount({ ...PANE, surface })
     expect(await ui.find({ type: 'Text', text: /Needs you · 1/ })).toBeDefined()
-    expect(await ui.find({ type: 'Text', text: /Active · 2/ })).toBeDefined()
+    expect(await ui.find({ type: 'Text', text: /Active · 3/ })).toBeDefined()
     expect(await ui.find({ type: 'Text', text: /Settled · 1/ })).toBeDefined()
     expect(await ui.find({ type: 'Text', text: /confirm: drop it\?/ })).toBeDefined()
+    expect((await ui.findAll({ type: 'Text', text: '● ' })).filter(dot => dot.props.color === 'blue')).toHaveLength(1)
+    expect((await ui.find({ type: 'Text', text: 'finished unseen' }))?.props.bold).toBe(true)
+    expect(await ui.find({ type: 'Text', text: 'still going' })).toBeUndefined()
     expect(await ui.find({ type: 'Text', text: /#7 open/ })).toBeDefined()
     expect(await ui.find({ text: /1 folded/ })).toBeDefined()
     expect(await ui.find({ text: /put away/ })).toBeUndefined()

data/mod/tests/snapshot.fixture.ts

@@ -14,7 +14,8 @@ export const SNAPSHOT = `{
         "session": "u-a1",
         "label": "needs an answer",
         "state": "blocked",
-        "actionable": true
+        "actionable": true,
+        "unread": true
       }
     ],
     "active": [
@@ -38,7 +39,8 @@ export const SNAPSHOT = `{
         "session": "u-c3",
         "label": "put away",
         "state": "done",
-        "actionable": true
+        "actionable": true,
+        "unread": true
       }
     ]
   }

data/mod/types/index.d.ts

@@ -10,6 +10,7 @@ export type InboxRow = {
   state: string
   actionable: boolean
   isWaiting: boolean
+  isUnread: boolean
   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.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Jordan Byron
@@ -116,6 +116,7 @@ files:
 - lib/claude_inbox/app/triaging.rb
 - lib/claude_inbox/app/updating.rb
 - lib/claude_inbox/cli.rb
+- lib/claude_inbox/clipboard.rb
 - lib/claude_inbox/config.rb
 - lib/claude_inbox/debug.rb
 - lib/claude_inbox/dialog.rb
@@ -127,6 +128,8 @@ files:
 - lib/claude_inbox/mod.rb
 - lib/claude_inbox/mouse.rb
 - lib/claude_inbox/new_session_form.rb
+- lib/claude_inbox/notifier.rb
+- lib/claude_inbox/notifier_app.rb
 - lib/claude_inbox/painter.rb
 - lib/claude_inbox/palette.rb
 - lib/claude_inbox/paste.rb
@@ -136,6 +139,7 @@ files:
 - lib/claude_inbox/reaper.rb
 - lib/claude_inbox/records.rb
 - lib/claude_inbox/remote/http.rb
+- lib/claude_inbox/remote/icon.icns
 - lib/claude_inbox/remote/icon.png
 - lib/claude_inbox/remote/icon.svg
 - lib/claude_inbox/remote/listener.rb
@@ -150,6 +154,7 @@ files:
 - lib/claude_inbox/settings.rb
 - lib/claude_inbox/slash_commands.rb
 - lib/claude_inbox/snapshot.rb
+- lib/claude_inbox/snooze_time.rb
 - lib/claude_inbox/store.rb
 - lib/claude_inbox/store/entry.rb
 - lib/claude_inbox/store/row.rb