claude-inbox 0.10.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56e25a548ff2899f765523fbf990e66b96f970915c8efafa39fb8834af99f6db
-  data.tar.gz: 590e72d23244e04517692beee562c53c59cecba10028b16ea9a371560392fcec
+  metadata.gz: 4be74e826e16c816d3589869198467177926961e11d885d7c811e6218b67fd2f
+  data.tar.gz: b09b5adfa01af2b64b00479faba7ce3c3312a8aec82916e1c0a003e7eec8f4ba
 SHA512:
-  metadata.gz: ffb0d572f03f482149ddf17f599d936a99de569340e6dbc61d587a5b736aa1919d78d300ddde35689e6b31b15a020eef350830668b046288df6925e021768ecb
-  data.tar.gz: 56805ff4fd994c5a22ef94742a801a6693b04b577f3ebfee63bb99271ff5de68f343e54f33011558852c7dbaeb6851124a944aa2b091190f95479ce51d2736fd
+  metadata.gz: 93865715d77fe8092727f66c32da8e6cdbbac67068c2ead4af429f35d488d034834c188dc74905e42b0c4ecdea8470a3770d870251c8f229a532f3006cc463b0
+  data.tar.gz: 5334bb968b0fc31caea4249abe7b838266a70e9513c2693baa68432bc20f6c8eef3f9ff2491a14af15caa168550a27fffc0d20a2879c953904029a526206f4e1

data/lib/claude_inbox/app/navigating.rb

@@ -47,6 +47,15 @@ module ClaudeInbox
         select(stops[(idx + delta).clamp(0, stops.size - 1)])
       end
 
+      # Before a row leaves the list: the stop below it, or above it at the
+      # bottom, so working down a section doesn't throw the cursor to the top.
+      def select_neighbour
+        stops = filtered.selections(@expanded)
+        idx = stops.index(@selected)
+        rest = stops - [@selected]
+        select(rest[idx.clamp(..rest.size - 1)]) if idx && rest.any?
+      end
+
       # Tab / Shift-Tab: first selectable row of the next / previous section.
       def jump_section(dir)
         sections = filtered

data/lib/claude_inbox/app/spawning.rb

@@ -9,7 +9,7 @@ module ClaudeInbox
       def open_new_session
         cwd = selected_session&.cwd || Dir.pwd
         dirs = SessionRequest.directories(@store.sessions, @trust.call)
-        @modal = NewSessionForm.new(cwd: SessionRequest.strip_worktree(cwd), color: @color, dirs: dirs)
+        @modal = NewSessionForm.new(cwd: SessionRequest.strip_worktree(cwd), dirs: dirs)
       end
 
       # `:start`/`:start_and_attach` leave the form as `@modal`, now busy: it

data/lib/claude_inbox/app/triaging.rb

@@ -33,7 +33,9 @@ module ClaudeInbox
 
       def settle_selected
         return unless require_storable
-        @store.settle(@selected.key)
+        key = @selected.key
+        select_neighbour
+        @store.settle(key)
         notice("settled — u brings it back")
       end
 
@@ -44,10 +46,16 @@ module ClaudeInbox
 
       def snooze_chosen
         return @modal = Dialog::Prompt.new(:snooze, @modal.id, "") if @modal.choice == :custom
-        @store.snooze(@modal.id, @modal.choice)
+        snooze_modal_row(@modal.choice)
         @modal = nil
       end
 
+      # A poll can move the cursor while the menu is up, so only step off a row still under it.
+      def snooze_modal_row(choice)
+        select_neighbour if @selected == Store::Selection.row(@modal.id)
+        @store.snooze(@modal.id, choice)
+      end
+
       def open_alias_editor
         return unless require_storable && require_writable("rename")
         current = @store.alias_for(@selected.key) || ""
@@ -67,7 +75,7 @@ module ClaudeInbox
         elsif @modal.kind == :snooze
           wake_at = SnoozeTime.parse(value, Time.now)
           return notice("try 45m, 2h, 3d, 17:00, 5pm, fri, tomorrow or tonight") unless wake_at
-          @store.snooze(@modal.id, wake_at)
+          snooze_modal_row(wake_at)
         elsif value.empty? || PullRequests.valid_url?(value)
           @store.set_pr(@modal.id, value)
           @poller.soon

data/lib/claude_inbox/app.rb

@@ -64,7 +64,7 @@ module ClaudeInbox
       @out = out
       @color = color
       @trust = trust
-      @renderer = Renderer.new(color: color)
+      @renderer = Renderer.new
       @input = Input.new(input, out)
       @queue = queue
       @poller = Poller.new(client: client, store: store, pull_requests: pull_requests,
@@ -275,6 +275,7 @@ module ClaudeInbox
         tick: @tick / 2, loading: loading_for, listening: @listener.snapshot
       )
       frame = @renderer.frame(sections, view)
+      frame = frame.plain unless @color # --no-color: decided here and nowhere else
       placed(frame)
       @terminal.paint(frame.lines)
       dt = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0

data/lib/claude_inbox/dialog.rb

@@ -3,6 +3,7 @@
 require "tty-box"
 require_relative "text"
 require_relative "text_buffer"
+require_relative "theme"
 
 module ClaudeInbox
   # A small box over the list that claims every key until it answers. Like
@@ -18,6 +19,7 @@ module ClaudeInbox
     def initialize(kind, id)
       @kind = kind
       @id = id
+      @theme = Theme.new
     end
 
     def frame(width, caret = nil)
@@ -29,6 +31,13 @@ module ClaudeInbox
     # How wide the box wants to be; the frame caps it at the terminal.
     def fit = self.class::WIDTH
 
+    private
+
+    def key(name) = @theme.cyan_bold(name)
+
+    # A key and what it does.
+    def hint(name, action) = "#{key(name)}  #{@theme.dim(action)}"
+
     # `s` snooze: one key per choice, and the choice is read from `choice`.
     class Snooze < Dialog
       MENU = [
@@ -45,11 +54,11 @@ module ClaudeInbox
 
       def title = " Snooze "
 
-      def lines(_width, _caret) = MENU.map { |k, label, _| "  #{k}  #{label}" } + ["", "  esc  cancel"]
+      def lines(_width, _caret) = MENU.map { |k, label, _| "  #{key(k)}  #{label}" } + ["", "  " + hint("esc", "cancel")]
 
       def press(name, key)
         return :cancel if name == :escape || key == "q"
-        entry = MENU.find { |k, _, _| k == key }
+        entry = MENU.assoc(key)
         return nil unless entry
         @choice = entry[2]
         :snooze
@@ -77,8 +86,8 @@ module ClaudeInbox
       def fit = [WIDTH, lines(Float::INFINITY, nil).map { |l| Text.width(l) }.max + MARGIN].max
 
       def lines(width, _caret)
-        (@prs.each_with_index.map { |pr, i| "  #{i + 1}  #{label(pr)}" } +
-          ["", "  #{KEYS.fetch(kind)}  #{VERBS.fetch(kind)} #{@prs.first.short} · esc cancel"])
+        (@prs.each_with_index.map { |pr, i| "  #{key((i + 1).to_s)}  #{label(pr)}" } +
+          ["", "  #{hint(KEYS.fetch(kind), "#{VERBS.fetch(kind)} #{@prs.first.short}")} · #{key("esc")} #{@theme.dim("cancel")}"])
           .map { |line| Text.truncate(line, width) }
       end
 
@@ -91,10 +100,11 @@ module ClaudeInbox
 
       private
 
-      # A bare #190 is ambiguous only once the list spans repos.
+      # The list's badge, then the title. A bare #190 is ambiguous only
+      # once the list spans repos.
       def label(pr)
         name = (@prs.map(&:repo).uniq.size > 1) ? pr.qualified : pr.short
-        ["#{name} #{pr.state&.downcase}".strip, pr.trouble, pr.title].compact.join(" · ")
+        pr.title ? @theme.pr_badge(pr, name) + @theme.dim(" · ") + pr.title : @theme.pr_badge(pr, name)
       end
     end
 
@@ -108,13 +118,13 @@ module ClaudeInbox
 
       def lines(_width, _caret)
         case kind
-        when :stop then ["  Stop session #{id}?", "", "  y  stop it", "  esc  cancel"]
+        when :stop then ["  Stop session #{id}?", "", "  " + hint("y", "stop it"), "  " + hint("esc", "cancel")]
         when :delete
           ["  Delete session #{id}?", "  Its worktree and conversation", "  go with it.",
-            "", "  y  delete it", "  esc  keep it"]
+            "", "  " + hint("y", "delete it"), "  " + hint("esc", "keep it")]
         when :adopt
           ["  Pull this session into the daemon?", "  Its phone session ends and a",
-            "  new one takes its place.", "", "  y  adopt it", "  esc  cancel"]
+            "  new one takes its place.", "", "  " + hint("y", "adopt it"), "  " + hint("esc", "cancel")]
         end
       end
 
@@ -160,7 +170,7 @@ module ClaudeInbox
           "",
           "  You can install this later with claude-inbox install",
           "",
-          "      y  add it to Claude Code      esc  not now"]
+          "      #{hint("y", "add it to Claude Code")}      #{hint("esc", "not now")}"]
       end
     end
 
@@ -181,7 +191,8 @@ module ClaudeInbox
       def title = TITLES.fetch(kind)
 
       def lines(width, caret)
-        [QUESTIONS.fetch(kind), "", "  > " + @buffer.row(width - 4, cursor: caret), "", "  ⏎ save · esc cancel"]
+        [QUESTIONS.fetch(kind), "", "  > " + @buffer.row(width - 4, cursor: caret), "",
+          "  #{key("⏎")} #{@theme.dim("save")} · #{key("esc")} #{@theme.dim("cancel")}"]
       end
 
       def press(name, key)

data/lib/claude_inbox/headless.rb

@@ -15,11 +15,15 @@ module ClaudeInbox
   # reaps, since deleting sessions stays with the inbox you can see, and it
   # exits at once while an inbox holds the writer lock.
   class Headless
+    RECHECK_EVERY = 60
+
     def initialize(client:, store:, pull_requests: PullRequests.new, actions: Actions.new, snapshot: Snapshot.new,
-      lock: WriterLock.new, updater: nil, notifier: Notifier.disabled)
+      lock: WriterLock.new, updater: nil, notifier: Notifier.disabled, recheck_every: RECHECK_EVERY)
       @lock = lock
       @snapshot = snapshot
       @updater = updater
+      @recheck_every = recheck_every
+      @notice = nil
       @queue = Queue.new
       @poller = Poller.new(client: client, store: store, pull_requests: pull_requests, reaper: Reaper.disabled,
         queue: @queue, snapshot: snapshot, actions: actions, notifier: notifier)
@@ -29,7 +33,7 @@ module ClaudeInbox
     def run
       return false unless @lock.take(role: "headless")
       @poller.start
-      check_for_update if @updater
+      Thread.new { watch_for_updates } if @updater
       loop { @queue.pop }
     end
 
@@ -38,8 +42,19 @@ module ClaudeInbox
     # After the poller is off, since the check may wait on the network. The
     # pane cannot swap the process under Claude Code, so the snapshot only
     # says a newer one is out, and a check that cannot tell says nothing.
+    # Re-checked because this process outlives an update applied from a
+    # terminal; the updater's day-long cache keeps that off the network.
+    def watch_for_updates
+      loop do
+        check_for_update
+        sleep @recheck_every
+      end
+    end
+
     def check_for_update
-      @snapshot.update = @updater.check&.notice
+      notice = @updater.check&.notice
+      return if notice == @notice
+      @notice = @snapshot.update = notice
       @poller.soon
     rescue Updater::Error
       nil

data/lib/claude_inbox/job_state.rb

@@ -14,10 +14,11 @@ module ClaudeInbox
   # The file tells them apart: `tempo` is the agent's own pulse, `fan` names
   # each outstanding piece of work, and `detail` is the session's own status
   # line, with `needs` naming what it is waiting on while blocked and
-  # `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, and `createdAt`, when it was.
+  # `output.result` what it produced once done. It also carries the PR links
+  # the daemon scanned out of the transcript and the transcript's path, 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, and `createdAt`, when it was.
   #
   # Never cached. A color changes the moment you type `/color`, so every poll
   # asks the file again.
@@ -65,7 +66,7 @@ module ClaudeInbox
       nil
     end
 
-    attr_reader :pr_urls, :color, :intent, :bridge_id, :created_at
+    attr_reader :pr_urls, :transcript_path, :color, :intent, :bridge_id, :created_at
 
     def initialize(hash)
       @detail = hash["detail"]
@@ -75,6 +76,7 @@ module ClaudeInbox
       @kinds = (hash["fan"] || []).filter_map { |f| f["kind"] }
       @tasks = (hash["inFlight"] || {})["tasks"].to_i
       @pr_urls = (hash["children"] || []).filter_map { |c| c["href"] if c["kind"] == "pr" }
+      @transcript_path = hash["linkScanPath"]
       @color = hash["color"]
       @intent = hash["intent"]
       @bridge_id = hash["bridgeSessionId"]

data/lib/claude_inbox/new_session_form.rb

@@ -35,10 +35,10 @@ module ClaudeInbox
     # editable field spends these on its own text instead.
     CYCLE = {:left => -1, :right => 1, "h" => -1, "l" => 1, " " => 1}.freeze
 
-    def initialize(cwd:, color:, dirs: [], home: Dir.home, clipboard: Images.method(:from_clipboard))
-      @p = Pastel.new(enabled: color)
-      @theme = Theme.new(enabled: color)
-      @palette = Palette.new(enabled: color)
+    def initialize(cwd:, dirs: [], home: Dir.home, clipboard: Images.method(:from_clipboard))
+      @p = Pastel.new(enabled: true)
+      @theme = Theme.new
+      @palette = Palette.new
       @home = home
       @clipboard = clipboard
       @places = dirs.map { |path| Place.new(path, SessionRequest.label(path, dirs), path.sub(/\A#{Regexp.escape(home)}(?=\/|\z)/, "~")) }

data/lib/claude_inbox/notifier.rb

@@ -46,6 +46,7 @@ module ClaudeInbox
       elsif row.session.effective_state == "done" then "finished"
       end
     end
+    private_class_method :alerts, :rows, :alert
 
     def initialize(app: NotifierApp.new, run: Subprocess.method(:capture), enabled: true)
       @app = app

data/lib/claude_inbox/palette.rb

@@ -22,12 +22,7 @@ module ClaudeInbox
 
     RESET = "\e[39m"
 
-    def initialize(enabled:)
-      @enabled = enabled
-    end
-
     def paint(text, name)
-      return text unless @enabled
       seq = SEQUENCES[name]
       seq ? seq + text + RESET : text
     end

data/lib/claude_inbox/pull_requests.rb

@@ -3,6 +3,7 @@
 require "json"
 require "time"
 require_relative "records"
+require_relative "stack_links"
 require_relative "subprocess"
 
 module ClaudeInbox
@@ -58,6 +59,8 @@ module ClaudeInbox
   # file, which JobState reads onto `job_state`; `claude agents --json` does
   # not expose them.
   # It is a link scan, so a session that merely mentions a PR gets it too.
+  # The daemon keeps one PR per session, so StackLinks adds the rest of a
+  # stack the session opened.
   # Interactive sessions have no job file; for those the store's `pr` override
   # is the only source.
   #
@@ -87,6 +90,7 @@ module ClaudeInbox
       @known = {}      # url => PullRequest
       @checked_at = {} # url => epoch seconds of the last gh call
       @mutex = Mutex.new
+      @stacks = StackLinks.new
     end
 
     # Each session with its `prs` set from what is already known, asking
@@ -96,7 +100,7 @@ module ClaudeInbox
     # override replaces the scanned list.
     def enrich(sessions, overrides)
       sessions.map do |s|
-        urls = overrides[s.key] ? [overrides[s.key]] : (s.job_state&.pr_urls || [])
+        urls = overrides[s.key] ? [overrides[s.key]] : scanned(s.job_state)
         s.with(prs: urls.map { |u| known(u) })
       end
     end
@@ -106,13 +110,8 @@ module ClaudeInbox
     # the caller knows whether the list is worth publishing again. A merge
     # date alone counts: it is what lets a PR the cache called merged settle.
     def refresh(sessions)
-      changed = false
-      fresh = sessions.map do |s|
-        s.with(prs: s.prs.map { |pr|
-          status(pr.url).tap { |now| changed = true if now != pr }
-        })
-      end
-      [fresh, changed]
+      fresh = sessions.map { |s| s.with(prs: s.prs.map { |pr| status(pr.url) }) }
+      [fresh, fresh.map(&:prs) != sessions.map(&:prs)]
     end
 
     # Best known state for a url, refreshed through gh when due.
@@ -159,8 +158,15 @@ module ClaudeInbox
       url.to_s.match?(%r{\Ahttps://github\.com/[^/\s]+/[^/\s]+/pull/\d+/?\z})
     end
 
+    private_class_method :health
+
     private
 
+    def scanned(job_state)
+      return [] unless job_state
+      (job_state.pr_urls + @stacks.urls(job_state.transcript_path)).uniq
+    end
+
     # Best known state for a url without asking gh.
     def known(url)
       @mutex.synchronize { @known[url] ||= seed(url) }

data/lib/claude_inbox/remote/pairing_dialog.rb

@@ -86,7 +86,8 @@ module ClaudeInbox
 
       def key_lines(s)
         return ["  paired phones get 401 until they pair again —", "  rotate? y/n"] if @asking
-        (s.state == :listening) ? ["  c copy  r new token  esc close"] : ["  esc close"]
+        keys = (s.state == :listening) ? [%w[c copy], ["r", "new token"], %w[esc close]] : [%w[esc close]]
+        ["  " + keys.map { |k, action| "#{key(k)} #{@theme.dim(action)}" }.join("  ")]
       end
     end
   end

data/lib/claude_inbox/renderer.rb

@@ -11,7 +11,10 @@ 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)
+    Frame = Struct.new(:lines, :items, :top) do
+      # The same frame for a terminal drawn without color.
+      def plain = self.class.new(lines.map { |l| Text.strip_ansi(l) }, items, top)
+    end
 
     CHROME_ROWS = 2 # header + footer
 
@@ -35,14 +38,6 @@ module ClaudeInbox
 
     SECTION_HUES = {pinned: :cyan, needs_you: :red, active: :yellow, snoozed: :purple}.freeze
 
-    # GitHub's colors. A draft has no hue, so it dims; a state missing from
-    # 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
@@ -67,10 +62,10 @@ module ClaudeInbox
       ["za", "fold"], ["/", "filter"], ["q", "quit"]
     ].freeze
 
-    def initialize(color:, home: Dir.home)
-      @p = Pastel.new(enabled: color)
-      @theme = Theme.new(enabled: color)
-      @palette = Palette.new(enabled: color)
+    def initialize(home: Dir.home)
+      @p = Pastel.new(enabled: true)
+      @theme = Theme.new
+      @palette = Palette.new
       @home = home
     end
 
@@ -178,15 +173,19 @@ module ClaudeInbox
         header_chip(settled, "◦", "settled", compact) { |s| @p.dim(s) }
       ]
       chips << @p.dim("nothing running") if sections.all.empty?
-      [*chips, listening_chip(listening)].compact.join(compact ? "  " : @p.dim("  ·  "))
-    end
-
-    # Red when the listener was asked for and isn't up. Nothing when it
-    # wasn't asked for.
-    def listening_chip(listening)
-      case listening&.state
-      when :listening then @theme.blue("◉ #{"lan" if listening.lan}:#{listening.port}")
-      when :in_use, :held, :failed then @theme.red("◉ !")
+      [*chips, listening_chip(listening, compact)].compact.join(compact ? "  " : @p.dim("  ·  "))
+    end
+
+    # Red, and saying why, when the listener was asked for and isn't up.
+    # Nothing when it wasn't asked for.
+    def listening_chip(listening, compact)
+      return unless listening
+      address = "#{"lan" if listening.lan}:#{listening.port}"
+      case listening.state
+      when :listening then @theme.blue("◉ #{address}")
+      when :held then @theme.red(compact ? "◉ #{address} held" : "◉ #{address} held by another inbox")
+      when :in_use then @theme.red("◉ #{address} in use")
+      when :failed then @theme.red("◉ #{address} failed")
       end
     end
 
@@ -216,20 +215,14 @@ module ClaudeInbox
       Text.pad(" " + section_color(name, "▎") + section_color(name, @p.bold(title)) + @p.dim("─" * fill) + @p.dim(count_s), width)
     end
 
-    def section_color(name, s) = tint(SECTION_HUES[name], s)
-
-    def tint(hue, s)
-      hue ? @theme.public_send(hue, s) : @p.dim(s)
-    end
+    def section_color(name, s) = @theme.tint(SECTION_HUES[name], s)
 
     # ----- body ---------------------------------------------------------------
 
     def body_lines(sections, width, view)
+      return [empty_state(width), []] if sections.all.empty?
       lines = []
       items = []
-      if sections.all.empty?
-        return [empty_state(width), []]
-      end
       selected = view.selected
       sections.each_pair do |name, rows|
         next if rows.empty?
@@ -324,7 +317,7 @@ module ClaudeInbox
 
       label_w = [width - chrome - Text.width(project_text), 0].max
       label = Text.truncate(row.label, label_w)
-      label = style_label(label, row, quiet, sel || (live && row.unread?))
+      label = style_label(label, row, quiet, sel || unread)
       first = " #{marker} #{glyph} " + Text.pad(label, label_w) + "  " + meta + "  " + project + " "
 
       return [Text.pad(first, width)] unless live
@@ -399,20 +392,13 @@ module ClaudeInbox
       pr ? base + @p.dim(" · ") + pr : base
     end
 
-    # "#885 open", or "#885 open · ✗ checks" when something is wrong. The
-    # headline PR is shown, with a count of the rest.
+    # The headline PR, with a count of the rest. A settled row dims it.
     def pr_badge(s, section)
       pr = s.pr
       return nil unless pr
+      badge = (section == :settled) ? @p.dim("#{pr.short} #{pr.state&.downcase}".strip) : @theme.pr_badge(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)
-      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
+      badge + more
     end
 
     def state_badge(s)

data/lib/claude_inbox/snooze_time.rb

@@ -65,5 +65,6 @@ module ClaudeInbox
       day = now.to_date + days
       Time.new(day.year, day.month, day.day, hour, minute, 0, now.utc_offset).to_i
     end
+    private_class_method :clock, :weekday, :next_at, :at
   end
 end

data/lib/claude_inbox/stack_links.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "json"
+
+module ClaudeInbox
+  # The PRs a session opened with `gh stack submit`, read from its
+  # transcript. The daemon links a session to one PR only, so a stack of
+  # three shows as its first; this finds the rest.
+  #
+  # Transcripts run to megabytes and every poll asks, so each file is read
+  # once and then only for what was appended since.
+  class StackLinks
+    # gh-stack's line for each PR it opens. Matched against a Bash result's
+    # own stdout, at the start of a line, so a session that merely quotes
+    # one doesn't count.
+    CREATED = %r{^✓ Created PR #\d+ \((https://github\.com/[^/\s]+/[^/\s]+/pull/\d+)\)}
+
+    def initialize
+      @seen = {} # path => [bytes read, urls]
+      @mutex = Mutex.new
+    end
+
+    # => the PR urls in creation order, [] for a missing or unreadable file.
+    def urls(path)
+      return [] unless path
+      @mutex.synchronize do
+        offset, urls = @seen.fetch(path, [0, []])
+        offset, urls = 0, [] if File.size(path) < offset
+        added = File.open(path, "r:UTF-8") { |f| f.seek(offset) && f.read }
+        complete = added.include?("\n") ? added[..added.rindex("\n")] : ""
+        @seen[path] = [offset + complete.bytesize, (urls + scan(complete)).uniq]
+        @seen[path].last
+      end
+    rescue SystemCallError
+      []
+    end
+
+    private
+
+    def scan(text)
+      text.each_line.select { |l| l.include?("Created PR #") }.flat_map do |line|
+        stdout = JSON.parse(line).dig("toolUseResult", "stdout")
+        stdout.is_a?(String) ? stdout.scan(CREATED).flatten : []
+      rescue JSON::ParserError
+        []
+      end
+    end
+  end
+end

data/lib/claude_inbox/store/sections.rb

@@ -14,8 +14,7 @@ module ClaudeInbox
       def section_of(selection)
         return nil if selection.nil?
         return selection.key if selection.fold?
-        each_pair { |name, rows| return name if rows.any? { |r| r.key == selection.key } }
-        nil
+        each_pair.find { |_, rows| rows.any? { |r| r.key == selection.key } }&.first
       end
 
       def selections(expanded) = stops(expanded).flat_map(&:last)

data/lib/claude_inbox/text.rb

@@ -7,6 +7,8 @@ module ClaudeInbox
   # session names carry emoji and glyphs that break byte/char slicing.
   module Text
     ANSI = /\e\[[0-9;?]*[A-Za-z]/
+    # A grapheme, or an escape that takes no column.
+    GLYPH = /#{ANSI}|\X/
     ELLIPSIS = "…"
 
     module_function
@@ -21,25 +23,26 @@ module ClaudeInbox
 
     def width(s) = Unicode::DisplayWidth.of(strip_ansi(s))
 
-    # Truncate plain (uncolored) text to `w` columns, appending an ellipsis
-    # when anything was cut. Handles wide glyphs by stepping grapheme by grapheme.
+    # Truncate to `w` columns, appending an ellipsis when anything was cut.
+    # Handles wide glyphs by stepping grapheme by grapheme.
     def truncate(s, w)
       return "" if w <= 0
       return s if width(s) <= w
       take(s, w - width(ELLIPSIS)) << ELLIPSIS
     end
 
-    # First `n` columns of plain text, no ellipsis.
+    # First `n` columns, no ellipsis. Colors survive the cut, and a reset
+    # closes whichever one the cut left open.
     def take(s, n)
       out = +""
       used = 0
-      s.each_grapheme_cluster do |g|
-        gw = Unicode::DisplayWidth.of(g)
+      s.scan(GLYPH) do |g|
+        gw = g.start_with?("\e") ? 0 : Unicode::DisplayWidth.of(g)
         break if used + gw > n
         out << g
         used += gw
       end
-      out
+      (out.include?("\e") && !out.end_with?("\e[0m")) ? out << "\e[0m" : out
     end
 
     # Plain text with its first `n` columns removed.
@@ -56,14 +59,10 @@ module ClaudeInbox
       out
     end
 
-    # Right-pad (ANSI-aware) to exactly `w` columns. Truncates if too long.
+    # Right-pad to exactly `w` columns. Truncates if too long.
     def pad(s, w)
-      cur = width(s)
-      if cur > w
-        s = truncate(strip_ansi(s), w)
-        cur = width(s)
-      end
-      s + (" " * [w - cur, 0].max)
+      s = truncate(s, w)
+      s + (" " * [w - width(s), 0].max)
     end
 
     # Greedy word wrap on display width. Words wider than `w` are split.

data/lib/claude_inbox/theme.rb

@@ -8,26 +8,39 @@ module ClaudeInbox
     HUES = {red: 203, green: 108, yellow: 179, blue: 75, purple: 176, cyan: 73}.freeze
     BG = 236
 
+    # GitHub's colors. A draft has no hue, so it dims; a state missing from
+    # 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
+
     HUES.each_key do |hue|
       define_method(hue) { |text| color(text, hue) }
       define_method(:"#{hue}_bold") { |text| color(text, hue, bold: true) }
     end
 
-    def initialize(enabled:)
-      @enabled = enabled
+    def dim(text) = "\e[2m#{text}\e[0m"
+
+    # The hue, or dim when there is none.
+    def tint(hue, text) = hue ? public_send(hue, text) : dim(text)
+
+    # "#885 open", or "#885 open · ✗ checks" when something is wrong.
+    # `name` replaces the bare number where that would be ambiguous.
+    def pr_badge(pr, name = pr.short)
+      return dim(name) unless PR_HUES.key?(pr.state)
+      badge = tint(PR_HUES[pr.state], "#{name} #{pr.state.downcase}")
+      pr.trouble ? badge + dim(" · ") + tint(PR_TROUBLE_HUES[pr.health], pr.trouble) : badge
     end
 
     # A filled pill: editor-background text on the hue, for a selected row
     # or choice — the inverse of `color`, which puts the hue on the text.
-    def pill(text, hue)
-      return text unless @enabled
-      "\e[38;5;#{BG};48;5;#{HUES.fetch(hue)}m#{text}\e[0m"
-    end
+    def pill(text, hue) = "\e[38;5;#{BG};48;5;#{HUES.fetch(hue)}m#{text}\e[0m"
 
     private
 
     def color(text, hue, bold: false)
-      return text unless @enabled
       codes = ["38;5;#{HUES.fetch(hue)}"]
       codes << "1" if bold
       "\e[#{codes.join(";")}m#{text}\e[0m"

data/lib/claude_inbox/writer_lock.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require_relative "subprocess"
 
 module ClaudeInbox
   # One snapshot writer per machine: the inbox you can see, else a headless
@@ -25,8 +26,8 @@ module ClaudeInbox
       file = File.open(@path, File::RDWR | File::CREAT, 0o600)
       return hold(file, role) if file.flock(File::LOCK_EX | File::LOCK_NB)
       holder_role, holder = file.read.split
-      return refuse(file) unless role == "inbox" && holder_role == "headless"
-      Process.kill("TERM", holder.to_i) if holder.to_i.positive? && holder.to_i != Process.pid
+      return refuse(file) unless role == "inbox" && holder_role == "headless" && headless?(holder.to_i)
+      Process.kill("TERM", holder.to_i)
       EVICT_TRIES.times do
         return hold(file, role) if file.flock(File::LOCK_EX | File::LOCK_NB)
         sleep 0.1
@@ -39,6 +40,14 @@ module ClaudeInbox
 
     private
 
+    # The file can name a pid that no longer holds the lock (#322), which by
+    # now may be some other process; only a headless claude-inbox is ended.
+    def headless?(pid)
+      return false unless pid.positive? && pid != Process.pid
+      command = Subprocess.capture("ps", "-o", "command=", "-p", pid.to_s).out
+      command.include?("claude-inbox") && command.split.include?("--headless")
+    end
+
     # After reading the holder the position sits at the end, and truncate does
     # not move it, so the write is rewound first or it lands after NUL padding.
     def hold(file, role)

data/lib/claude_inbox.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: claude-inbox
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.1
 platform: ruby
 authors:
 - Jordan Byron
@@ -155,6 +155,7 @@ files:
 - lib/claude_inbox/slash_commands.rb
 - lib/claude_inbox/snapshot.rb
 - lib/claude_inbox/snooze_time.rb
+- lib/claude_inbox/stack_links.rb
 - lib/claude_inbox/store.rb
 - lib/claude_inbox/store/entry.rb
 - lib/claude_inbox/store/row.rb