claude-inbox 0.1.0 → 0.3.0

data/lib/claude_inbox/dialog.rb

@@ -10,6 +10,8 @@ module ClaudeInbox
   # the details read off the dialog afterwards. `frame(width)` is the box
   # Renderer overlays. Pure: nothing here touches the store or the client.
   class Dialog
+    WIDTH = 44
+
     attr_reader :kind, :id
 
     def initialize(kind, id)
@@ -18,7 +20,7 @@ module ClaudeInbox
     end
 
     def frame(width, caret = nil)
-      box = [width - 4, 44].min
+      box = [width - 4, self.class::WIDTH].min
       TTY::Box.frame(lines(box - 4, caret).join("\n"), title: {top_left: title}, padding: [0, 1], width: box)
         .split("\n")
     end
@@ -49,10 +51,11 @@ module ClaudeInbox
       end
     end
 
-    # `X` stop and `Ctrl-x` delete both ask first and both take `y`, but the
-    # words differ because the outcomes do: read the box before answering.
+    # `X` stop, `Ctrl-x` delete and Enter on a remote row all ask first and
+    # all take `y`, but the words differ because the outcomes do: read the
+    # box before answering.
     class Confirm < Dialog
-      TITLES = {stop: " Stop ", delete: " Delete "}.freeze
+      TITLES = {stop: " Stop ", delete: " Delete ", adopt: " Adopt "}.freeze
 
       def title = TITLES.fetch(kind)
 
@@ -62,6 +65,9 @@ module ClaudeInbox
         when :delete
           ["  Delete session #{id}?", "  Its worktree and conversation", "  go with it.",
             "", "  y  delete it", "  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"]
         end
       end
 

data/lib/claude_inbox/images.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "securerandom"
 require_relative "subprocess"
 
 module ClaudeInbox
-  # Images a prompt can carry: a dropped file, or whatever is on the
-  # clipboard. Both come back as a path for a TextBuffer chip to hold.
+  # Images a prompt can carry: a dropped file, whatever is on the
+  # clipboard, or the bytes a request sent. Each comes back as a path for
+  # the prompt to mention.
   module Images
     DEFAULT_DIR = File.join(Dir.home, ".config", "claude-inbox", "images")
     EXTENSIONS = %w[.png .jpg .jpeg .gif .webp .bmp .svg].freeze
@@ -14,9 +16,19 @@ module ClaudeInbox
 
     Clipboard = Struct.new(:image, :text)
 
-    # Saved images are pruned here, on the way in, because nothing else
-    # knows when a session stopped needing its image. macOS only: osascript
-    # ships with the OS, and PNG is the flavor a screenshot puts there.
+    class Unsupported < StandardError; end
+
+    # Bytes from a request carry no file name worth trusting, so the type
+    # comes from the magic number at the front.
+    MAGIC = {
+      ".png" => /\A\x89PNG/n,
+      ".jpg" => /\A\xFF\xD8\xFF/n,
+      ".gif" => /\AGIF8/n,
+      ".webp" => /\ARIFF.{4}WEBP/mn
+    }.freeze
+
+    # macOS only: osascript ships with the OS, and PNG is the flavor a
+    # screenshot puts there.
     def self.from_clipboard(dir: DEFAULT_DIR, now: Time.now, run: Subprocess.method(:capture))
       FileUtils.mkdir_p(dir)
       prune(dir, now)
@@ -26,6 +38,23 @@ module ClaudeInbox
       Clipboard.new(nil, (text.success? && !text.out.empty?) ? text.out : nil)
     end
 
+    # `index` orders the images one request brings; the random part keeps
+    # two requests saving in the same millisecond apart. Readable by the
+    # owner only: a photo can be anything.
+    def self.save(bytes, dir: DEFAULT_DIR, now: Time.now, index: 1)
+      data = bytes.b
+      ext = extension(data)
+      raise Unsupported, "not a PNG, JPEG, GIF or WebP image" unless ext
+      FileUtils.mkdir_p(dir)
+      prune(dir, now)
+      path = File.join(dir, "#{now.strftime("%Y%m%d-%H%M%S-%L")}-#{index}-#{SecureRandom.hex(3)}#{ext}")
+      File.open(path, File::WRONLY | File::CREAT | File::EXCL | File::BINARY, 0o600) { |f| f.write(data) }
+      path
+    end
+
+    # ".png", ".jpg", ".gif" or ".webp" by the magic number, or nil.
+    def self.extension(bytes) = MAGIC.find { |_, magic| magic.match?(bytes.b) }&.first
+
     CLIPBOARD_PNG = <<~APPLESCRIPT
       on run argv
         set png to the clipboard as «class PNGf»
@@ -46,8 +75,10 @@ module ClaudeInbox
       File.file?(path) ? path : nil
     end
 
+    # Pruned on the way in, because nothing else knows when a session
+    # stopped needing its image.
     def self.prune(dir, now)
-      Dir.glob(File.join(dir, "*.png")).each do |f|
+      Dir.glob(EXTENSIONS.map { |ext| File.join(dir, "*#{ext}") }).each do |f|
         File.delete(f) if now - File.mtime(f) > KEEP_FOR
       rescue SystemCallError
         nil

data/lib/claude_inbox/job_state.rb

@@ -13,8 +13,9 @@ module ClaudeInbox
   # 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, and the color `/color`
-  # set on the session, which `claude agents --json` drops.
+  # 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.
   #
   # Never cached. A color changes the moment you type `/color`, so every poll
   # asks the file again.
@@ -49,7 +50,7 @@ module ClaudeInbox
       nil
     end
 
-    attr_reader :detail, :needs, :result, :tempo, :kinds, :tasks, :pr_urls, :color
+    attr_reader :detail, :needs, :result, :pr_urls, :color, :intent, :bridge_id
 
     def initialize(hash)
       @detail = hash["detail"]
@@ -60,18 +61,31 @@ module ClaudeInbox
       @tasks = (hash["inFlight"] || {})["tasks"].to_i
       @pr_urls = (hash["children"] || []).select { |c| c["kind"] == "pr" && c["href"] }.map { |c| c["href"] }
       @color = hash["color"]
+      @intent = hash["intent"]
+      @bridge_id = hash["bridgeSessionId"]
+      @flags = hash["respawnFlags"] || []
     end
 
-    # The agent itself is not thinking. On its own this means little — a
-    # session whose process died leaves the same reading behind — so it only
-    # says something paired with work still in flight.
-    def agent_idle? = tempo == "idle"
-
-    def in_flight? = tasks.positive?
+    # The flags the session was started with, which the daemon puts back on
+    # a wake, are the only record of Remote Control being on it.
+    def remote_control? = flags.include?("--remote-control")
 
     # True when the agent has stopped and is only waiting on what it started.
     def waiting_on_work? = agent_idle? && in_flight?
 
+    # What the session needs while blocked, what it produced once done,
+    # otherwise its status line; nil before it has said anything.
+    def summary(state)
+      line =
+        case state
+        when "blocked" then needs || detail
+        when "done" then result || detail
+        else detail
+        end
+      line = line.to_s.gsub(/\s+/, " ").strip
+      line.empty? ? nil : line
+    end
+
     # "1 shell", "2 agents · 1 shell". Falls back to a bare count for a state
     # file that counts the open tasks without naming them.
     def in_flight_label
@@ -82,6 +96,15 @@ module ClaudeInbox
 
     private
 
+    attr_reader :tempo, :kinds, :tasks, :flags
+
+    # The agent itself is not thinking. On its own this means little — a
+    # session whose process died leaves the same reading behind — so it only
+    # says something paired with work still in flight.
+    def agent_idle? = tempo == "idle"
+
+    def in_flight? = tasks.positive?
+
     def count_label = "#{tasks} #{plural("task", tasks)}"
 
     def plural(word, n) = (n == 1) ? word : "#{word}s"

data/lib/claude_inbox/keymap.rb

@@ -26,8 +26,8 @@ module ClaudeInbox
       "h" => :collapse,
       "s" => :snooze, "u" => :wake, "a" => :alias, "x" => :settle, "X" => :stop,
       :ctrl_x => :delete,
-      "o" => :open_pr, "P" => :link_pr, "t" => :toggle_pin,
-      "R" => :refresh, "p" => :toggle_peek, "n" => :new_session,
+      "o" => :open_pr, "P" => :link_pr, "t" => :toggle_pin, "w" => :open_remote,
+      "R" => :refresh, "p" => :toggle_peek, "n" => :new_session, "N" => :remote_pairing,
       :tab => :next_section, :back_tab => :prev_section,
       "/" => :filter, :escape => :escape,
       "q" => :quit, :ctrl_c => :quit

data/lib/claude_inbox/logs.rb

@@ -18,8 +18,11 @@ module ClaudeInbox
       @pending = nil
       @pending_at = nil
       @requests = Queue.new
+    end
+
+    def start
+      return if @thread&.alive?
       @thread = Thread.new { worker }
-      @thread.abort_on_exception = false
     end
 
     def cached(id)
@@ -42,7 +45,7 @@ module ClaudeInbox
       @requests << id unless fresh
     end
 
-    def stop = @thread.kill
+    def stop = @thread&.kill
 
     private
 

data/lib/claude_inbox/new_session_form.rb

@@ -2,6 +2,7 @@
 
 require_relative "agents_client"
 require_relative "images"
+require_relative "session_request"
 require_relative "settings"
 require_relative "slash_commands"
 require_relative "text"
@@ -17,15 +18,18 @@ module ClaudeInbox
     # string on :choice ones — `kind` says which.
     Field = Struct.new(:key, :label, :kind, :value, :choices)
 
-    # "default" stays the internal value so spawn_args leaves the flag off;
-    # the screen shows what that resolves to instead.
+    # The screen shows what "default" resolves to; `values` makes it nil.
     DEFAULT = "default"
 
     MENU_ROWS = 6
 
-    def initialize(cwd:, pastel:, theme: Theme.new(enabled: pastel.enabled), home: Dir.home, clipboard: Images.method(:from_clipboard))
+    # Keys a :choice field answers to, as the step through its choices; an
+    # editable field spends these on its own text instead.
+    CYCLE = {:left => -1, :right => 1, "h" => -1, "l" => 1, " " => 1}.freeze
+
+    def initialize(cwd:, pastel:, home: Dir.home, clipboard: Images.method(:from_clipboard))
       @p = pastel
-      @theme = theme
+      @theme = Theme.new(enabled: pastel.enabled)
       @home = home
       @clipboard = clipboard
       @fields = [
@@ -35,7 +39,8 @@ module ClaudeInbox
         Field.new(:model, "Model", :choice, DEFAULT, AgentsClient::MODELS),
         Field.new(:effort, "Effort", :choice, DEFAULT, AgentsClient::EFFORTS),
         Field.new(:permission_mode, "Permissions", :choice, DEFAULT, AgentsClient::PERMISSION_MODES),
-        Field.new(:worktree, "Worktree", :choice, "no", %w[no yes])
+        Field.new(:worktree, "Worktree", :choice, "no", %w[no yes]),
+        Field.new(:remote, "Remote Control", :choice, DEFAULT, [DEFAULT, "no", "yes"])
       ]
       @focus = 0
       @error = nil
@@ -44,12 +49,19 @@ module ClaudeInbox
       @pick = 0
       @dismissed = nil
       @confirm_discard = false
+      @busy = false
     end
 
     def focused = @fields[@focus]
 
     # => :cancel | :start | :start_and_attach | :changed
     def press(name, raw)
+      # `:start`/`:start_and_attach` leave the form up until the spawn is
+      # known to have worked, so a failure (untrusted directory, `claude`
+      # missing, ...) can hand the composed prompt back instead of losing
+      # it; there is no way to cancel a spawn already under way, so every
+      # key is swallowed until the App reports back.
+      return :changed if @busy
       return confirm_discard_press(name, raw) if @confirm_discard
       @error = nil
       @candidates = nil
@@ -106,18 +118,18 @@ module ClaudeInbox
     def picked = menu&.fetch(@pick.clamp(0, menu.size - 1))
 
     def values
-      @fields.to_h { |f| [f.key, f.value.to_s] }.tap do |v|
-        v[:prompt] = @fields[0].value.expand { |chip| AgentsClient.mention(chip.path) }.strip
-        v[:worktree] = v[:worktree] == "yes"
-        v[:name] = nil if v[:name].strip.empty?
-        v[:cwd] = File.expand_path(v[:cwd].strip.empty? ? "." : v[:cwd].strip)
-      end
+      v = @fields.to_h { |f| [f.key, (f.kind == :choice && f.value == DEFAULT) ? nil : f.value.to_s] }
+      v[:prompt] = field(:prompt).value.expand { |chip| AgentsClient.mention(chip.path) }.strip
+      v[:worktree] = v[:worktree] == "yes"
+      v[:name] = nil if v[:name].strip.empty?
+      v[:cwd] = directory
+      v[:remote] = SessionRequest::FLAGS[v[:remote]]
+      SessionRequest.resolve(v, defaults(v[:cwd]))
     end
 
     # Settings resolve against the directory the session will run in, so
     # they follow the Directory field.
-    def defaults
-      cwd = values[:cwd]
+    def defaults(cwd = directory)
       return @defaults if @defaults_for == cwd
       @defaults_for = cwd
       @defaults = Settings.defaults(cwd, home: @home)
@@ -126,7 +138,7 @@ module ClaudeInbox
     # Project commands live under the Directory field's path, so they
     # follow it as the defaults do.
     def commands
-      cwd = values[:cwd]
+      cwd = directory
       return @commands if @commands_for == cwd
       @commands_for = cwd
       @commands = SlashCommands.list(cwd: cwd, home: @home)
@@ -140,27 +152,23 @@ module ClaudeInbox
       menu_rows = menu_lines(inner_w, [height - fixed - 3, MENU_ROWS].min)
       prompt_h = [height - fixed - menu_rows.size, 3].max
       out = [""]
-      out << "  " + (@confirm_discard ? @theme.red("Discard this session? (y/n)") : @p.bold("New session"))
+      title = @busy ? @p.dim("Starting session…") : @p.bold("New session")
+      out << "  " + (@confirm_discard ? @theme.red("Discard this session? (y/n)") : title)
       out << ""
-      out << "  " + field_label(@fields[0]) + @p.dim("  ⏎ newline")
-      out += prompt_box(@fields[0], inner_w, prompt_h)
+      out << "  " + field_label(field(:prompt)) + @p.dim("  ⏎ newline")
+      out += prompt_box(field(:prompt), inner_w, prompt_h)
       out += menu_rows
       out << ""
-      @fields[1..].each { |f| out << "  " + field_label(f) + field_value(f, inner_w - 14) }
+      @fields[1..].each { |f| out << "  " + field_label(f) + field_value(f, inner_w - 16) }
       out.first(height) + [""] * [height - out.size, 0].max
     end
 
     def footer
-      if @confirm_discard
-        return [["y", "discard"], ["esc", "keep editing"]]
-            .map { |k, d| @theme.cyan_bold(k) + " " + @p.dim(d) }.join("  ")
-      end
+      return @p.dim("starting session…") if @busy
+      return hints([["y", "discard"], ["esc", "keep editing"]]) if @confirm_discard
       return @theme.red(@error) if @error
       return @p.dim("matches: ") + @candidates.join(@p.dim("  ")) if @candidates
-      if menu
-        return [["↑ ↓", "choose"], ["⇥ ⏎", "pick"], ["esc", "close"]]
-            .map { |k, d| @theme.cyan_bold(k) + " " + @p.dim(d) }.join("  ")
-      end
+      return hints([["↑ ↓", "choose"], ["⇥ ⏎", "pick"], ["esc", "close"]]) if menu
       keys =
         case focused.kind
         when :multiline then [["⏎", "newline"], ["^V", "image"]]
@@ -169,14 +177,24 @@ module ClaudeInbox
         end
       keys += [["^S", "start"], ["^O", "start & open"],
         ["⇥", (focused.key == :cwd) ? "complete / next" : "next"], ["esc", "cancel"]]
-      keys.map { |k, d| @theme.cyan_bold(k) + " " + @p.dim(d) }.join("  ")
+      hints(keys)
+    end
+
+    # The App's `claude --bg` call failed after `:start`/`:start_and_attach`
+    # already handed the form off — an untrusted directory, a stale binary,
+    # a permissions error. The composed prompt is still here, so the form
+    # reopens on it with the reason shown instead of the App just logging
+    # the failure and losing the draft.
+    def submission_failed(message)
+      @busy = false
+      @error = message
     end
 
     private
 
     # Esc with a prompt typed asks first, so a stray keypress can't lose it.
     def escape_pressed
-      return :cancel if @fields[0].value.empty?
+      return :cancel if field(:prompt).value.empty?
       @confirm_discard = true
       :changed
     end
@@ -242,9 +260,11 @@ module ClaudeInbox
       rows
     end
 
+    def hints(pairs) = pairs.map { |k, d| @theme.cyan_bold(k) + " " + @p.dim(d) }.join("  ")
+
     def field_label(f)
       on = f.equal?(focused)
-      (on ? @theme.cyan_bold("▶ ") : "  ") + (on ? @p.bold(Text.pad(f.label, 12)) : @p.dim(Text.pad(f.label, 12)))
+      (on ? @theme.cyan_bold("▶ ") : "  ") + (on ? @p.bold(Text.pad(f.label, 14)) : @p.dim(Text.pad(f.label, 14)))
     end
 
     # The cell the cursor sits on, drawn as a block by inverting it: a bar
@@ -325,38 +345,30 @@ module ClaudeInbox
 
     def move(d) = @focus = (@focus + d) % @fields.size
 
-    # Keys a :choice field answers to; an editable field spends these on its
-    # own text instead.
-    def choose(name, raw)
-      case name
-      when :left then cycle(-1)
-      when :right then cycle(1)
-      else
-        case raw
-        when "h" then cycle(-1)
-        when "l", " " then cycle(1)
-        end
-      end
+    def field(key) = @fields.find { |f| f.key == key }
+
+    def directory
+      path = field(:cwd).value.to_s.strip
+      File.expand_path(path.empty? ? "." : path)
     end
 
-    def cycle(d)
+    def focus_on(key) = @focus = @fields.index { |f| f.key == key }
+
+    def choose(name, raw)
+      d = CYCLE[name] || CYCLE[raw]
+      return unless d
       f = focused
-      return unless f.kind == :choice
       f.value = f.choices[(f.choices.index(f.value) + d) % f.choices.size]
     end
 
     def submit(attach:)
-      v = values
-      if v[:prompt].empty?
-        @error = "a prompt is required"
-        @focus = 0
-        return :changed
-      end
-      unless File.directory?(v[:cwd])
-        @error = "no such directory: #{v[:cwd]}"
-        @focus = 2
+      field, message = SessionRequest.problem(values)
+      if field
+        @error = message
+        focus_on(field)
         return :changed
       end
+      @busy = true
       attach ? :start_and_attach : :start
     end
   end

data/lib/claude_inbox/painter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "tty-cursor"
+
+module ClaudeInbox
+  # Diffs successive frames and writes only changed rows. No erase-to-end-of-
+  # line after a row: in the terminal's last column the cursor stays put
+  # (pending wrap), so EL would eat the glyph just drawn.
+  class Painter
+    def initialize(out, cursor: TTY::Cursor)
+      @out = out
+      @cursor = cursor
+      @prev = []
+    end
+
+    def paint(lines)
+      buf = +""
+      lines.each_with_index do |line, i|
+        next if @prev[i] == line
+        buf << @cursor.move_to(0, i) << line
+      end
+      if @prev.size > lines.size
+        (lines.size...@prev.size).each { |i| buf << @cursor.move_to(0, i) << @cursor.clear_line }
+      end
+      @out.print buf unless buf.empty?
+      @out.flush
+      @prev = lines
+    end
+
+    def invalidate = @prev = []
+  end
+end

data/lib/claude_inbox/palette.rb

@@ -17,15 +17,10 @@ module ClaudeInbox
 
     INDEXED = {"orange" => 208, "pink" => 205}.freeze
 
-    RESET = "\e[39m"
-
-    def self.known?(name) = ANSI.key?(name) || INDEXED.key?(name)
+    SEQUENCES = ANSI.transform_values { |n| "\e[#{n}m" }
+      .merge(INDEXED.transform_values { |n| "\e[38;5;#{n}m" }).freeze
 
-    def self.sequence(name)
-      return "\e[#{ANSI[name]}m" if ANSI.key?(name)
-      return "\e[38;5;#{INDEXED[name]}m" if INDEXED.key?(name)
-      nil
-    end
+    RESET = "\e[39m"
 
     def initialize(enabled: true)
       @enabled = enabled
@@ -33,7 +28,7 @@ module ClaudeInbox
 
     def paint(text, name)
       return text unless @enabled
-      seq = self.class.sequence(name)
+      seq = SEQUENCES[name]
       seq ? seq + text + RESET : text
     end
   end

data/lib/claude_inbox/peek.rb

@@ -7,7 +7,7 @@ module ClaudeInbox
   # lands on a warm cache. Main-thread state only.
   class Peek
     TERMINAL_NOTE = "This is a claude you opened in a terminal yourself. The daemon can't attach to it, read its output, or stop it from outside. Switch to that window."
-    REMOTE_NOTE = "This is a Remote Control session driven from claude.ai/code. The daemon can't attach to it or read its output from here. Open it in the web or mobile app instead."
+    REMOTE_NOTE = "This is a Remote Control session driven from claude.ai/code. The daemon can't attach to it or read its output from here. Enter pulls it into the daemon; w opens it in the web or mobile app."
 
     # What Renderer paints: the body lines, the title bar, the dim line under it.
     View = Struct.new(:lines, :title, :subtitle)
@@ -44,9 +44,9 @@ module ClaudeInbox
 
     # `row` is the selected row as the frame shows it, or nil when nothing is
     # selected. Answers nil when there is no pane to paint.
-    def view(row, height)
+    def view(row, body_h)
       return nil unless @open && @selected&.row?
-      View.new(scrolled(body(row), height - 2), row&.label || @selected.key, subtitle(row))
+      View.new(scrolled(body(row), body_h), row&.label || @selected.key, subtitle(row))
     end
 
     private
@@ -58,7 +58,7 @@ module ClaudeInbox
     end
 
     def interactive_note(s)
-      [s.remote? ? REMOTE_NOTE : TERMINAL_NOTE, "", "pid #{s.pid} · #{s.cwd}", "session #{s.session_id}"]
+      [s.remote? ? REMOTE_NOTE : TERMINAL_NOTE, "", "pid #{s.pid} · #{s.cwd}", "session #{s.session_id}", s.remote_url].compact
     end
 
     def subtitle(row)

data/lib/claude_inbox/poller.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-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 +13,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
@@ -36,8 +34,10 @@ module ClaudeInbox
 
     def stop = @thread&.kill
 
-    # Skips the poll rather than the timer, so nothing forks `claude` while
-    # another process holds the terminal. A poll already under way finishes.
+    # Only skips polls while another process holds the terminal; a poll
+    # already under way finishes. Forking from another thread meanwhile, as
+    # a remote start does, is fine: Subprocess puts every child in its own
+    # session, away from the tty.
     def pause = @lock.synchronize { @paused = true }
 
     def resume
@@ -55,8 +55,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 +67,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 +89,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/pull_requests.rb

@@ -85,11 +85,6 @@ module ClaudeInbox
       [fresh, changed]
     end
 
-    # Best known state for a url without asking gh.
-    def known(url)
-      @mutex.synchronize { @known[url] ||= seed(url) }
-    end
-
     # Best known state for a url, refreshed through gh when due.
     def status(url)
       @mutex.synchronize do
@@ -119,6 +114,11 @@ module ClaudeInbox
 
     private
 
+    # Best known state for a url without asking gh.
+    def known(url)
+      @mutex.synchronize { @known[url] ||= seed(url) }
+    end
+
     def due?(url)
       @gh && @clock.call.to_i - @checked_at.fetch(url, 0) >= REFRESH_AFTER
     end