claude-inbox 0.5.0 → 0.6.0

data/lib/claude_inbox/paste.rb

@@ -24,7 +24,7 @@ module ClaudeInbox
 
     def feed(raw)
       out = []
-      rest = raw.to_s
+      rest = raw
       until rest.empty?
         if @open
           body, close, rest = rest.partition(CLOSE)

data/lib/claude_inbox/peek.rb

@@ -16,7 +16,6 @@ module ClaudeInbox
       @logs = logs
       @open = false
       @offset = 0
-      @selected = nil
       @session = nil
     end
 
@@ -30,8 +29,7 @@ module ClaudeInbox
     def close = @open = false
 
     # Called on every selection change; a fold has no session.
-    def select(selection, session)
-      @selected = selection
+    def select(session)
       @session = session
       @offset = 0
       @logs.want(session.id) if session&.actionable?
@@ -42,17 +40,16 @@ module ClaudeInbox
       @offset = [@offset + delta, 0].max
     end
 
-    # `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.
+    # `row` is the selected row as the frame shows it, or nil on a fold or
+    # with nothing selected. Answers nil when there is no pane to paint.
     def view(row, body_h)
-      return nil unless @open && @selected&.row?
-      View.new(scrolled(body(row), body_h), row&.label || @selected.key, subtitle(row))
+      return nil unless @open && row
+      View.new(scrolled(body(row), body_h), row.label, subtitle(row))
     end
 
     private
 
     def body(row)
-      return ["(nothing selected)"] unless row
       return interactive_note(row.session) if row.session.interactive?
       @logs.cached(row.session.id) || ["(loading…)"]
     end
@@ -62,7 +59,6 @@ module ClaudeInbox
     end
 
     def subtitle(row)
-      return nil unless row
       s = row.session
       parts = [s.effective_state, s.status, s.waiting_for, s.id, s.started_at&.strftime("started %b %-d %H:%M")].compact
       parts += s.prs.map { |pr| "#{pr.short} #{pr.state&.downcase || "?"}" }

data/lib/claude_inbox/poller.rb

@@ -5,7 +5,7 @@ require_relative "sessions"
 module ClaudeInbox
   # Asks `claude agents` for the list off the main thread, every INTERVAL
   # seconds and on demand, puts what it finds in the store and the snapshot,
-  # and tells App over the shared queue: [:sessions, list] for each
+  # 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
@@ -70,11 +70,9 @@ module ClaudeInbox
       @queue << [:error, e.message]
     end
 
-    # Applies the requests another front end left, and says whether any landed.
+    # Applies the requests another front end left.
     def apply
-      return false unless @actions.drain(@store) > 0
-      write_snapshot
-      true
+      write_snapshot if @actions.drain(@store) > 0
     end
 
     private
@@ -82,7 +80,7 @@ module ClaudeInbox
     def publish(sessions)
       @store.update(sessions)
       write_snapshot
-      @queue << [:sessions, sessions]
+      @queue << [:sessions]
     end
 
     def write_snapshot

data/lib/claude_inbox/pull_requests.rb

@@ -10,7 +10,7 @@ module ClaudeInbox
   # 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, :title, :resolved_at) do
+  PullRequest = Struct.new(:number, :url, :state, :resolved_at) do
     def short = number ? "##{number}" : url.to_s.sub(%r{\Ahttps?://(www\.)?}, "")
 
     def merged? = state == "MERGED"
@@ -115,7 +115,7 @@ 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, title: h["title"], resolved_at: resolved_at)
+      PullRequest.new(number: h["number"], url: h["url"] || url, state: state, resolved_at: resolved_at)
     rescue JSON::ParserError, ArgumentError
       nil
     end
@@ -140,7 +140,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"),
-        title: cached&.dig("title"), resolved_at: cached&.dig("resolved_at"))
+        resolved_at: cached&.dig("resolved_at"))
     end
 
     # Same shape as Claude Code's cache, so `seed` reads both alike.
@@ -154,13 +154,13 @@ module ClaudeInbox
 
     # Under @mutex.
     def remember(pr)
-      resolved[pr.url] = {"number" => pr.number, "state" => pr.state, "title" => pr.title, "resolved_at" => pr.resolved_at}
+      resolved[pr.url] = {"number" => pr.number, "state" => pr.state, "resolved_at" => pr.resolved_at}
       return unless @resolved_path
       Records.save(@resolved_path, resolved)
     end
 
     def fetch(url)
-      r = Subprocess.capture(@gh, "pr", "view", url, "--json", "number,state,isDraft,title,url,closedAt")
+      r = Subprocess.capture(@gh, "pr", "view", url, "--json", "number,state,isDraft,url,closedAt")
       r.success? ? self.class.parse(url, r.out) : nil
     rescue SystemCallError
       nil

data/lib/claude_inbox/reaper.rb

@@ -73,7 +73,7 @@ module ClaudeInbox
       row.key
     rescue AgentsClient::Error => e
       reason = e.message.lines.first.to_s.strip
-      @store.mark_reap_failed(row.key, reason)
+      @store.mark_reap_failed(row.key)
       write(log, row, now_i, "kept — #{reason}")
       nil
     end

data/lib/claude_inbox/remote/http.rb

@@ -12,7 +12,7 @@ module ClaudeInbox
       TOKEN = /\A[!#$%&'*+\-.^_`|~0-9A-Za-z]+\z/
 
       REASONS = {
-        100 => "Continue", 200 => "OK", 201 => "Created", 400 => "Bad Request", 401 => "Unauthorized",
+        200 => "OK", 201 => "Created", 400 => "Bad Request", 401 => "Unauthorized",
         403 => "Forbidden", 404 => "Not Found", 405 => "Method Not Allowed", 409 => "Conflict",
         411 => "Length Required", 413 => "Content Too Large", 415 => "Unsupported Media Type",
         421 => "Misdirected Request", 422 => "Unprocessable Content", 500 => "Internal Server Error",

data/lib/claude_inbox/remote/page.html

@@ -124,6 +124,9 @@ code { font: 15px ui-monospace, SFMono-Regular, Menlo, monospace; }
   <label for="permission_mode">Permissions</label>
   <select id="permission_mode"></select>
   <p class="error" id="error-permission_mode"></p>
+  <label for="color">Color</label>
+  <select id="color"></select>
+  <p class="error" id="error-color"></p>
 
   <div class="toggles">
     <label class="toggle">Worktree <input type="checkbox" id="worktree" switch></label>
@@ -152,7 +155,7 @@ code { font: 15px ui-monospace, SFMono-Regular, Menlo, monospace; }
 const MAX_IMAGES = 8;
 const MAX_BODY = 16777216;
 const LONG_EDGE = 2000;
-const FIELDS = ["prompt", "name", "cwd", "model", "effort", "permission_mode", "images"];
+const FIELDS = ["prompt", "name", "cwd", "model", "effort", "permission_mode", "color", "images"];
 const NO_ANSWER = "no answer from the inbox. Is it open with --listen-lan, and is the Mac awake?";
 const REJECTED = "token rejected: press N in the inbox and pair again";
 const TOKEN = /^[A-Za-z0-9_-]{32,}$/;
@@ -223,9 +226,9 @@ function fill() {
   $("cwd").replaceChildren(...dirs.map((d) => new Option(d.label, d.path)), new Option("another directory…", ""));
   $("cwd").value = typed || !dirs.length ? "" : last || dirs[0].path;
   if (typed) $("cwd-other").value = last;
-  for (const [id, list] of [["model", options.models], ["effort", options.efforts], ["permission_mode", options.permission_modes]]) {
+  for (const [id, list] of [["model", options.models], ["effort", options.efforts], ["permission_mode", options.permission_modes], ["color", options.colors]]) {
     const picked = $(id).value;
-    $(id).replaceChildren(...(list || []).map((v) => new Option(v, v)));
+    $(id).replaceChildren(...(list || []).map((v) => new Option(id === "color" && v === "default" ? "none" : v, v)));
     if ((list || []).includes(picked)) $(id).value = picked;
   }
   relabel();
@@ -380,7 +383,7 @@ async function start() {
     const fields = {
       prompt: $("prompt").value, name: $("name").value, cwd: cwd(),
       model: $("model").value, effort: $("effort").value, permission_mode: $("permission_mode").value,
-      worktree: $("worktree").checked, remote: remote
+      color: $("color").value, worktree: $("worktree").checked, remote: remote
     };
     const body = JSON.stringify({...fields, images: images.map((image) => ({data: image.url.slice(image.url.indexOf(",") + 1)}))});
     const size = new Blob([body]).size;

data/lib/claude_inbox/remote/pairing.rb

@@ -28,7 +28,8 @@ module ClaudeInbox
       # Ethernet and Wi-Fi (en*) first: the first private address is the one
       # `c` copies, and a VM's bridge is no use to a phone.
       def self.addresses(interfaces = Socket.getifaddrs)
-        interfaces.select { |i| i.addr&.ip? }.sort_by.with_index { |i, n| [i.name.start_with?("en") ? 0 : 1, n] }.map(&:addr)
+        en, rest = interfaces.select { |i| i.addr&.ip? }.partition { |i| i.name.start_with?("en") }
+        (en + rest).map(&:addr)
       end
 
       # :off, :on or :block_all; nil without macOS's application firewall.

data/lib/claude_inbox/remote/start.rb

@@ -58,6 +58,7 @@ module ClaudeInbox
           models: AgentsClient::MODELS,
           efforts: AgentsClient::EFFORTS,
           permission_modes: AgentsClient::PERMISSION_MODES & @allowed_modes,
+          colors: AgentsClient::COLORS,
           dirs: paths.map { |path| {path: path, label: SessionRequest.label(path, paths), defaults: @settings.call(path).to_h} }
         }
       end

data/lib/claude_inbox/renderer.rb

@@ -64,7 +64,7 @@ module ClaudeInbox
       ["za", "fold"], ["/", "filter"], ["q", "quit"]
     ].freeze
 
-    def initialize(color: true, home: Dir.home)
+    def initialize(color:, home: Dir.home)
       @p = Pastel.new(enabled: color)
       @theme = Theme.new(enabled: color)
       @palette = Palette.new(enabled: color)

data/lib/claude_inbox/session_request.rb

@@ -15,11 +15,12 @@ module ClaudeInbox
       end
     end
 
-    KEYS = %w[prompt name cwd model effort permission_mode worktree remote].freeze
+    KEYS = %w[prompt name cwd model effort permission_mode worktree remote color].freeze
     CHOICES = {
       model: AgentsClient::MODELS,
       effort: AgentsClient::EFFORTS,
-      permission_mode: AgentsClient::PERMISSION_MODES
+      permission_mode: AgentsClient::PERMISSION_MODES,
+      color: AgentsClient::COLORS
     }.freeze
     FLAGS = {true => true, false => false, "yes" => true, "no" => false}.freeze
     MAX_PROMPT = 100_000
@@ -42,7 +43,8 @@ module ClaudeInbox
         effort: choice_param(:effort, params["effort"]),
         permission_mode: choice_param(:permission_mode, params["permission_mode"]),
         worktree: flag_param(:worktree, params["worktree"]) || false,
-        remote: flag_param(:remote, params["remote"])
+        remote: flag_param(:remote, params["remote"]),
+        color: choice_param(:color, params["color"])
       }
     end
 
@@ -78,7 +80,7 @@ module ClaudeInbox
     # A session's cwd may sit inside a worktree another agent is using;
     # carrying that into a new prompt would spawn the new agent there too,
     # writing over the same files. Fall back to the repo it was cut from.
-    def self.strip_worktree(cwd) = cwd.to_s.sub(%r{/\.claude/worktrees/[^/]+(?:/.*)?\z}, "")
+    def self.strip_worktree(cwd) = cwd.sub(%r{/\.claude/worktrees/[^/]+(?:/.*)?\z}, "")
 
     # Where sessions ran lately, newest first, then every directory whose
     # trust dialog was accepted: the likely choices first. Only an order;

data/lib/claude_inbox/slash_commands.rb

@@ -23,7 +23,7 @@ module ClaudeInbox
 
     # The project wins over the home directory when both define the same
     # name, as it does in the CLI.
-    def list(cwd:, home: Dir.home)
+    def list(cwd:, home:)
       found = {}
       add = ->(cmd) { found[cmd.name] ||= cmd }
       from_dir(File.join(cwd, ".claude")).each(&add)
@@ -44,7 +44,7 @@ module ClaudeInbox
         commands(File.join(dir, "commands"), prefix:)
     end
 
-    def skills(dir, prefix: nil)
+    def skills(dir, prefix:)
       Dir.glob(File.join(dir, "*", "SKILL.md")).sort.filter_map do |path|
         meta = frontmatter(path)
         next if meta["user-invocable"] == "false"
@@ -54,7 +54,7 @@ module ClaudeInbox
     end
 
     # A command file's name is its own; a subdirectory only groups them.
-    def commands(dir, prefix: nil)
+    def commands(dir, prefix:)
       Dir.glob(File.join(dir, "**", "*.md")).sort.map do |path|
         name = File.basename(path, ".md")
         Command.new(qualify(prefix, name), frontmatter(path)["description"].to_s)

data/lib/claude_inbox/snapshot.rb

@@ -15,20 +15,25 @@ module ClaudeInbox
 
     def initialize(path: DEFAULT_PATH)
       @path = path
+      @update = nil
       @body = nil
       @written_at = nil
       @mutex = Mutex.new
     end
 
+    # The notice for a newer claude-inbox, or nil. Held here rather than passed
+    # to each write because the poller writes too, without knowing of it.
+    attr_writer :update
+
     # Called from the poller's threads and the screen's alike.
     def write(sections, now)
       return unless @path
-      body = sections.to_h { |name, rows| [name.to_s, rows.map { |row| row_hash(row) }] }
+      body = {"sections" => sections.to_h { |name, rows| [name.to_s, rows.map { |row| row_hash(row) }] }, "update" => @update}.compact
       @mutex.synchronize do
         return if body == @body && now.to_i - @written_at < HEARTBEAT
         @body = body
         @written_at = now.to_i
-        Records.save(@path, {"version" => 1, "written_at" => @written_at, "sections" => body})
+        Records.save(@path, {"version" => 1, "written_at" => @written_at, **body})
       end
     end
 
@@ -39,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,
+        "waiting" => s.waiting_on_work? || 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/store/entry.rb

@@ -81,9 +81,9 @@ module ClaudeInbox
         row = Row.new(session: session, entry: self)
         @h.delete("wake_at") if row.woken?(now_i)
         @h.delete("snoozed_at") unless wake_at
-        @h.delete("settled_at") if settled_at && !row.hand_settled?
-        @h.delete("acknowledged_at") if acknowledged_at && !row.acknowledged?
-        @h.delete("revived_at") if revived_at && !row.revived?
+        @h.delete("settled_at") unless row.hand_settled?
+        @h.delete("acknowledged_at") unless row.acknowledged?
+        @h.delete("revived_at") unless row.revived?
         self
       end
 
@@ -133,9 +133,8 @@ module ClaudeInbox
 
       # So the Reaper backs off instead of shelling out every poll at a
       # worktree that is never going to let go of its unpushed commits.
-      def mark_reap_failed(now, message)
+      def mark_reap_failed(now)
         @h["reap_failed_at"] = now.to_i
-        @h["reap_error"] = message.to_s.lines.first&.strip
       end
     end
   end

data/lib/claude_inbox/store/sections.rb

@@ -4,9 +4,9 @@ module ClaudeInbox
   class Store
     # The Rows of one poll, grouped and ordered, and where the cursor may land among them.
     Sections = Struct.new(:pinned, :needs_you, :active, :snoozed, :settled) do
-      def each_section = SECTIONS.each { |k| yield k, self[k] }
+      def each_section(&) = each_pair(&)
 
-      def all = SECTIONS.flat_map { |k| self[k] }
+      def all = values.flatten(1)
 
       def row(selection)
         all.find { |r| r.key == selection.key } if selection&.row?
@@ -35,7 +35,7 @@ module ClaudeInbox
 
       # An empty fold is left out, since there is nothing under it to open.
       def stops(expanded)
-        SECTIONS.filter_map do |name|
+        members.filter_map do |name|
           rows = self[name]
           if !Store.folded?(name, expanded) then [name, rows.select(&:selectable?).map { |r| Selection.row(r.key) }]
           elsif rows.any? then [name, [Selection.fold(name)]]

data/lib/claude_inbox/store.rb

@@ -19,7 +19,6 @@ module ClaudeInbox
     # UNSETTLEABLE on purpose: `failed` earns a permanent row because you
     # should see it, but after REAP_AFTER of not seeing it, you never will.
     UNREAPABLE = %w[working].freeze
-    SECTIONS = %i[pinned needs_you active snoozed settled].freeze
     NotWritable = Class.new(StandardError)
     # Sections long enough to be worth hiding behind a fold toggle.
     FOLDABLE_SECTIONS = %i[snoozed settled].freeze
@@ -102,7 +101,7 @@ module ClaudeInbox
 
     def settle(id) = edit(id, "settle") { |e| e.settle(@clock.call) }
 
-    def mark_reap_failed(id, message) = edit(id) { |e| e.mark_reap_failed(@clock.call, message) }
+    def mark_reap_failed(id) = edit(id) { |e| e.mark_reap_failed(@clock.call) }
 
     def toggle_pin(id) = edit(id, "pin") { |e| e.toggle_pin(@clock.call) }
 

data/lib/claude_inbox/text_buffer.rb

@@ -37,8 +37,7 @@ module ClaudeInbox
 
     def initialize(text = "")
       @widths = Hash.new { |h, s| h[s] = Text.width(s) }
-      @g = text.grapheme_clusters
-      @cursor = @g.size
+      replace(text)
     end
 
     def to_s = @g.join
@@ -62,7 +61,6 @@ module ClaudeInbox
     def replace(text)
       @g = text.grapheme_clusters
       @cursor = @g.size
-      self
     end
 
     # Everything before the cursor, as one string.
@@ -89,9 +87,8 @@ module ClaudeInbox
       place(Pasted.new(@pastes = (@pastes || 0) + 1, text))
     end
 
-    # Handles one keypress — readline's editing keys, plus printable text —
-    # or returns false when the key is not ours and the caller should deal
-    # with it (Tab, Enter, Escape, anything else unprintable).
+    # Handles one keypress: readline's editing keys, plus printable text.
+    # Anything else (Tab, Enter, Escape) is ignored.
     def press(name, raw)
       case name
       when :left then @cursor = [@cursor - 1, 0].max
@@ -104,10 +101,9 @@ module ClaudeInbox
       when :ctrl_k then delete(@cursor, @g.size - @cursor)
       when :ctrl_w then delete_word
       else
-        return false unless raw.is_a?(String) && raw.match?(/\A[[:print:]]+\z/)
+        return unless raw.is_a?(String) && raw.match?(/\A[[:print:]]+\z/)
         insert(raw)
       end
-      true
     end
 
     # The text as a single row of at most `width` columns, scrolled right so
@@ -248,7 +244,6 @@ module ClaudeInbox
     def place(chip)
       @g.insert(@cursor, chip)
       @cursor += 1
-      chip
     end
 
     def delete(at, length)

data/lib/claude_inbox/theme.rb

@@ -13,7 +13,7 @@ module ClaudeInbox
       define_method(:"#{hue}_bold") { |text| color(text, hue, bold: true) }
     end
 
-    def initialize(enabled: true)
+    def initialize(enabled:)
       @enabled = enabled
     end
 

data/lib/claude_inbox/updater.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "net/http"
+require "rbconfig"
+require_relative "../claude_inbox"
+require_relative "mod"
+require_relative "subprocess"
+
+module ClaudeInbox
+  # Finds and installs a newer claude-inbox: from a gem, the latest release on
+  # rubygems.org; from a checkout, what main's tracking branch has. Every
+  # collaborator is injectable so the spec touches neither network nor git.
+  class Updater
+    ROOT = File.expand_path("../..", __dir__)
+    CACHE_PATH = File.join(Dir.home, ".config", "claude-inbox", "update.json")
+    LATEST_URL = "https://rubygems.org/api/v1/versions/claude-inbox/latest.json"
+    FRESH_FOR = 24 * 60 * 60
+    TIMEOUT = 5
+
+    # The check could not tell: rubygems.org or the remote is unreachable.
+    class Error < StandardError; end
+
+    # `kind` is :gem or :checkout. `behind` counts a checkout's commits and is
+    # nil for a gem.
+    Update = Data.define(:kind, :current, :latest, :behind) do
+      def notice = (kind == :gem) ? "v#{latest} available" : "main is #{behind} behind"
+
+      def installing
+        (kind == :gem) ? "Installing claude-inbox #{latest} over #{current}..." : "main is #{behind} behind, fast-forwarding to #{latest}..."
+      end
+    end
+
+    Applied = Data.define(:success, :output) do
+      def success? = success
+    end
+
+    def self.fetch_url(url)
+      uri = URI(url)
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: true, open_timeout: TIMEOUT, read_timeout: TIMEOUT) do |http|
+        http.get(uri.request_uri)
+      end
+      raise Error, "#{uri.host} answered #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+      response.body
+    rescue SystemCallError, SocketError, IOError, Timeout::Error, OpenSSL::SSL::SSLError => e
+      raise Error, "#{uri.host} is unreachable: #{e.message}"
+    end
+
+    def initialize(checkout: Mod::CHECKOUT, root: ROOT, version: VERSION, cache_path: CACHE_PATH,
+      run: Subprocess.method(:capture), fetch: Updater.method(:fetch_url),
+      exec: ->(*argv) { Kernel.exec(*Subprocess.command(*argv)) }, clock: -> { Time.now })
+      @checkout = checkout
+      @root = root
+      @version = version
+      @cache_path = cache_path
+      @run = run
+      @fetch = fetch
+      @exec = exec
+      @clock = clock
+    end
+
+    def kind = @checkout ? :checkout : :gem
+
+    # The newer version there is, or nil when this one is the latest. Asks the
+    # network at most once a day unless forced: what it last heard is kept in
+    # the cache file, and a check within the day compares against that.
+    def check(force: false)
+      known = force ? nil : fresh_cache
+      latest = known || fetch_latest
+      write_cache(latest) unless known
+      compare(latest)
+    end
+
+    # What a check within the day found, without asking the network: nil
+    # when it found nothing newer, or there was no check.
+    def cached
+      latest = fresh_cache
+      compare(latest) if latest
+    end
+
+    # Installs the latest: `gem install`, or a fast-forward of main, refused
+    # on another branch or a dirty tree rather than merged over. Success
+    # drops the cache, so a launch that auto-updates cannot apply the same
+    # version again and again should the launcher still resolve to this one.
+    def apply
+      applied = @checkout ? apply_checkout : install_gem
+      FileUtils.rm_f(@cache_path) if applied.success?
+      applied
+    end
+
+    # Replaces this process with a fresh launch on the same arguments. The
+    # gem's binstub resolves to the newest installed version, and a checkout's
+    # bin/claude-inbox runs whatever main now holds. The child's environment
+    # is Subprocess's unbundled one, so a Gemfile.lock cannot pin the binstub
+    # to the version just replaced.
+    def relaunch(argv)
+      launcher = @checkout ? File.join(@root, "bin", "claude-inbox") : "claude-inbox"
+      @exec.call(launcher, *argv)
+    end
+
+    private
+
+    def compare(latest) = @checkout ? checkout_update(latest) : gem_update(latest)
+
+    def install_gem
+      result = @run.call(Gem.ruby, File.join(RbConfig::CONFIG["bindir"], "gem"), "install", "claude-inbox")
+      Applied.new(success: result.success?, output: result.out + result.err)
+    end
+
+    def gem_update(latest)
+      return nil unless Gem::Version.new(latest) > Gem::Version.new(@version)
+      Update.new(kind: :gem, current: @version, latest: latest, behind: nil)
+    end
+
+    def checkout_update(latest)
+      behind = git("rev-list", "--count", "main..#{latest}").to_i
+      return nil if behind.zero?
+      Update.new(kind: :checkout, current: git("rev-parse", "--short", "main"), latest: latest[0, 7], behind: behind)
+    end
+
+    def fetch_latest
+      return fetch_upstream if @checkout
+      JSON.parse(@fetch.call(LATEST_URL)).fetch("version")
+    rescue JSON::ParserError, KeyError
+      raise Error, "rubygems.org sent something other than a version"
+    end
+
+    # Fetches the remote main tracks rather than a fixed URL, so a fork's
+    # clone follows the fork.
+    def fetch_upstream
+      remote = git("config", "branch.main.remote") or raise Error, "main tracks no remote"
+      fetched = @run.call("git", "-C", @root, "fetch", "--quiet", remote)
+      raise Error, "git fetch #{remote} failed: #{fetched.err.strip}" unless fetched.success?
+      git("rev-parse", "main@{upstream}") or raise Error, "main tracks no remote"
+    end
+
+    def apply_checkout
+      branch = git("symbolic-ref", "--short", "HEAD")
+      return Applied.new(success: false, output: "not on main (on #{branch})") unless branch == "main"
+      return Applied.new(success: false, output: "the working tree is dirty") unless git("status", "--porcelain") == ""
+      merged = @run.call("git", "-C", @root, "merge", "--ff-only", "--quiet", "main@{upstream}")
+      Applied.new(success: merged.success?, output: merged.out + merged.err)
+    end
+
+    def git(*args)
+      result = @run.call("git", "-C", @root, *args)
+      result.out.strip if result.success?
+    end
+
+    def fresh_cache
+      cache = JSON.parse(File.read(@cache_path))
+      cache["latest"] if cache["kind"] == kind.to_s && @clock.call.to_i - cache["checked_at"].to_i < FRESH_FOR
+    rescue SystemCallError, JSON::ParserError, TypeError
+      nil
+    end
+
+    def write_cache(latest)
+      FileUtils.mkdir_p(File.dirname(@cache_path))
+      File.write(@cache_path, JSON.generate(checked_at: @clock.call.to_i, kind: kind, latest: latest))
+    end
+  end
+end

data/lib/claude_inbox.rb

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