claude-inbox 0.3.0 → 0.4.0

data/lib/claude_inbox/app.rb

@@ -20,6 +20,9 @@ require_relative "reaper"
 require_relative "poller"
 require_relative "rate_limits"
 require_relative "session_request"
+require_relative "actions"
+require_relative "snapshot"
+require_relative "switch"
 
 module ClaudeInbox
   # Owns the terminal and the key loop. The only class allowed to spawn a
@@ -28,19 +31,23 @@ module ClaudeInbox
     # The reaper deletes sessions and the listener lets other machines in,
     # so both are off unless `bin/claude-inbox` switches them on.
     def initialize(client: AgentsClient.new, store: Store.new, pull_requests: PullRequests.new,
-      rate_limits: RateLimits.new, reaper: Reaper.disabled, listen: nil, out: $stdout, input: $stdin, color: true,
+      rate_limits: RateLimits.new, reaper: Reaper.disabled, snapshot: Snapshot.disabled, switch: Switch.disabled,
+      actions: Actions.disabled, listen: nil, out: $stdout, input: $stdin, color: true,
       terminal: Terminal.new(out, input), queue: Queue.new)
       @client = client
       @store = store
+      @snapshot = snapshot
+      @switch = switch
       @rate_limits = rate_limits
       @terminal = terminal
       @color = color
       @renderer = Renderer.new(color: color)
+      @input = input
       @reader = TTY::Reader.new(input: input, output: out, interrupt: :noop)
       @queue = queue
       @poller = Poller.new(client: client, store: store, pull_requests: pull_requests,
-        reaper: reaper, queue: @queue)
-      @listener = listen ? Remote::Listener.new(client: client, store: store, queue: @queue, jobs_dir: client.jobs_dir, **listen) : Remote::Listener.disabled
+        reaper: reaper, queue: @queue, snapshot: snapshot, actions: actions)
+      @listener = listen ? Remote::Listener.new(client: client, store: store, queue: @queue, **listen) : Remote::Listener.disabled
       @logs = Logs.new(client)
       @peek = Peek.new(@logs)
       @selected = nil
@@ -80,8 +87,10 @@ module ClaudeInbox
         @resize = false
         @terminal.resized
       end
-      render
       handle_input(input) if input
+      # A paste arrives a character per read and shows nothing until it
+      # closes, so a frame per character would only stall a long one.
+      render unless @paste.pasting?
     end
 
     private
@@ -109,7 +118,6 @@ module ClaudeInbox
         kind, *rest = @queue.pop(true)
         case kind
         when :sessions
-          @store.update(rest[0])
           @last_poll = Time.now
           @error = nil
         when :error then @error = rest[0]
@@ -128,7 +136,19 @@ module ClaudeInbox
     # ----- main loop --------------------------------------------------------
 
     def main_loop
-      step(@reader.read_keypress(echo: false, raw: false, nonblock: true)) until @quit
+      step(@paste.pasting? ? read_pasted : @reader.read_keypress(echo: false, raw: false, nonblock: true)) until @quit
+    end
+
+    # As much of an open paste as has arrived, read straight off the tty:
+    # the reader switches echo off and back on around every character, and
+    # on a long paste that is most of the wait.
+    def read_pasted
+      return nil unless @input.wait_readable(0.1)
+      out = +""
+      while out.size < 65_536 && @input.wait_readable(0) && (c = @input.getc)
+        out << c
+      end
+      out
     end
 
     def handle_input(raw)
@@ -153,7 +173,9 @@ module ClaudeInbox
     def render
       t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       now = Time.now
-      sections = filtered(@store.sections(now))
+      all = @store.sections(now)
+      @snapshot.write(all, now)
+      sections = filtered(all)
       width, height = @terminal.size
       body_h = Renderer.body_height(height)
       ensure_selection(sections)
@@ -229,6 +251,13 @@ module ClaudeInbox
       false
     end
 
+    # The edits with no request form, which a second inbox cannot keep.
+    def require_writable(verb)
+      return true if @store.writable?
+      notice("another claude-inbox owns state.json — #{verb} there")
+      false
+    end
+
     def notice(msg)
       @notice = [msg, Time.now + 4]
     end
@@ -389,12 +418,17 @@ module ClaudeInbox
       notice("settled — u brings it back")
     end
 
+    # The pane in the attached session may ask for a different one: the
+    # attach ends and the next starts without passing through the list. The
+    # poller keeps running meanwhile, so the pane's snapshot stays fresh.
     def attach(id)
-      @store.acknowledge(id)
-      @poller.pause
-      @terminal.release { @client.attach(id) }
-    ensure
-      @poller.resume
+      while id
+        @store.acknowledge(id)
+        @switch.clear
+        from = @store.sessions.find { |s| s.key == id }&.session_id
+        @terminal.release { @client.attach(id) { @switch.requested_for?(from) } }
+        id = @switch.take(@store.sessions.select(&:actionable?).map(&:key))
+      end
     end
 
     # ----- modals -----------------------------------------------------------
@@ -410,13 +444,13 @@ module ClaudeInbox
     end
 
     def open_alias_editor
-      return unless require_storable
+      return unless require_storable && require_writable("rename")
       current = @store.alias_for(@selected.key) || ""
       @modal = Dialog::Prompt.new(:alias, @selected.key, current)
     end
 
     def open_pr_editor
-      return unless require_storable
+      return unless require_storable && require_writable("link a pull request")
       current = @store.pr_for(@selected.key) || selected_session&.pr&.url || ""
       @modal = Dialog::Prompt.new(:pr, @selected.key, current)
     end

data/lib/claude_inbox/headless.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "actions"
+require_relative "poller"
+require_relative "pull_requests"
+require_relative "reaper"
+require_relative "snapshot"
+require_relative "writer_lock"
+
+module ClaudeInbox
+  # The poller with no terminal, for a front end that only reads the
+  # snapshot: it polls, writes the file and applies the requests. It never
+  # 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
+    def initialize(client:, store:, pull_requests: PullRequests.new, snapshot: Snapshot.new, actions: Actions.new,
+      lock: WriterLock.new, queue: Queue.new)
+      @lock = lock
+      @queue = queue
+      @poller = Poller.new(client: client, store: store, pull_requests: pull_requests, reaper: Reaper.disabled,
+        queue: queue, snapshot: snapshot, actions: actions)
+    end
+
+    # False when the lock is held, by an inbox or another headless process.
+    def run
+      return false unless @lock.take(role: "headless")
+      @poller.start
+      loop { @queue.pop }
+    end
+  end
+end

data/lib/claude_inbox/job_state.rb

@@ -38,19 +38,19 @@ module ClaudeInbox
     # Each background session with its job file read onto `job_state`, or nil
     # when there is none: interactive sessions have no job file, and neither
     # does one the daemon has already forgotten. Sessions.load calls this.
-    def self.enrich(sessions, jobs_dir: DEFAULT_DIR)
+    def self.enrich(sessions, jobs_dir:)
       sessions.map { |s| s.background? ? s.with(job_state: read(s.id, jobs_dir: jobs_dir)) : s }
     end
 
     # => JobState, or nil when there is no readable file for this id.
-    def self.read(id, jobs_dir: DEFAULT_DIR)
+    def self.read(id, jobs_dir:)
       return nil unless id
       new(JSON.parse(File.read(File.join(jobs_dir, id, "state.json"))))
     rescue JSON::ParserError, SystemCallError
       nil
     end
 
-    attr_reader :detail, :needs, :result, :pr_urls, :color, :intent, :bridge_id
+    attr_reader :pr_urls, :color, :intent, :bridge_id
 
     def initialize(hash)
       @detail = hash["detail"]
@@ -96,7 +96,7 @@ module ClaudeInbox
 
     private
 
-    attr_reader :tempo, :kinds, :tasks, :flags
+    attr_reader :detail, :needs, :result, :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

data/lib/claude_inbox/keymap.rb

@@ -38,8 +38,6 @@ module ClaudeInbox
       "z" => {"o" => :fold_open, "c" => :fold_close, "a" => :fold_toggle}
     }.freeze
 
-    attr_reader :pending
-
     def initialize(clock: -> { Time.now })
       @clock = clock
       @pending = nil

data/lib/claude_inbox/mod.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module ClaudeInbox
+  # Where the Claude Code pane ships, and a path to it that holds still: the
+  # gem's own folder moves with every version, so a link under ~/.config is
+  # what settings.json names, refreshed by the installed gem on every launch.
+  module Mod
+    DIR = File.expand_path("../../mod", __dir__)
+    LINK = File.join(Dir.home, ".config", "claude-inbox", "mod")
+    NAME = "inbox-pane"
+    CHECKOUT = File.exist?(File.expand_path("../../.git", __dir__))
+    # What the pane runs headless: a checkout's own, or the gem's from PATH.
+    COMMAND = CHECKOUT ? File.expand_path("../../bin/claude-inbox", __dir__) : nil
+
+    # Points the link at this gem's mod folder and returns the link. A folder
+    # of that name that is not a link is left alone. From a checkout only a
+    # missing or dangling link is made, unless forced (`--mod-dir` asks for
+    # it), so a worktree's launch never takes the path from the installed gem.
+    def self.link(link: LINK, dir: DIR, force: false, checkout: CHECKOUT)
+      FileUtils.mkdir_p(File.dirname(link))
+      return link if File.exist?(link) && !File.symlink?(link)
+      if File.symlink?(link)
+        return link if File.readlink(link) == dir
+        return link if checkout && !force && File.directory?(File.readlink(link))
+        File.delete(link)
+      end
+      File.symlink(dir, link)
+      link
+    end
+
+    Installed = Data.define(:added, :removed, :command_set)
+
+    # Links the mod and adds the link to CLAUDE_CODE_PLUGIN_DIRS in Claude
+    # Code's user settings, keeping any folders already there; forced, it
+    # drops the other folders holding this plugin, such as a worktree's, and
+    # sets the command the pane runs to this copy's. Raises JSON::ParserError
+    # rather than rewrite a settings file it cannot read.
+    def self.install(settings: File.join(Dir.home, ".claude", "settings.json"), link: LINK, dir: DIR, force: false, command: COMMAND)
+      self.link(link: link, dir: dir, force: true)
+      json = File.exist?(settings) ? JSON.parse(File.read(settings)) : {}
+      env = json["env"] ||= {}
+      dirs = env["CLAUDE_CODE_PLUGIN_DIRS"].to_s.split(File::PATH_SEPARATOR).map(&:strip).reject(&:empty?)
+      kept = dirs.reject { |d| force && d != link && plugin?(d) }
+      wanted = kept.include?(link) ? kept : [*kept, link]
+      options = json.dig("pluginConfigs", NAME, "options") || {}
+      replace = force && options["command"] != command
+      installed = Installed.new(added: !kept.include?(link), removed: dirs - kept, command_set: replace)
+      return installed if wanted == dirs && !replace
+
+      if replace
+        command ? options["command"] = command : options.delete("command")
+        ((json["pluginConfigs"] ||= {})[NAME] ||= {})["options"] = options
+      end
+      env["CLAUDE_CODE_PLUGIN_DIRS"] = wanted.join(File::PATH_SEPARATOR)
+      FileUtils.mkdir_p(File.dirname(settings))
+      File.write("#{settings}.tmp", JSON.pretty_generate(json) + "\n")
+      File.rename("#{settings}.tmp", settings)
+      installed
+    end
+
+    def self.plugin?(folder)
+      JSON.parse(File.read(File.join(folder, ".claude-plugin", "plugin.json")))["name"] == NAME
+    rescue Errno::ENOENT, Errno::ENOTDIR, Errno::EACCES, JSON::ParserError
+      false
+    end
+    private_class_method :plugin?
+  end
+end

data/lib/claude_inbox/new_session_form.rb

@@ -103,11 +103,6 @@ module ClaudeInbox
       :changed
     end
 
-    def command_query
-      return nil unless focused.key == :prompt
-      focused.value.head[/(?:\A|\s)\/(\S*)\z/, 1]
-    end
-
     def menu
       q = command_query
       return nil if q.nil? || @dismissed == q
@@ -124,26 +119,18 @@ module ClaudeInbox
       v[:name] = nil if v[:name].strip.empty?
       v[:cwd] = directory
       v[:remote] = SessionRequest::FLAGS[v[:remote]]
-      SessionRequest.resolve(v, defaults(v[:cwd]))
+      SessionRequest.resolve(v, defaults)
     end
 
     # Settings resolve against the directory the session will run in, so
     # they follow the Directory field.
-    def defaults(cwd = directory)
+    def defaults
+      cwd = directory
       return @defaults if @defaults_for == cwd
       @defaults_for = cwd
       @defaults = Settings.defaults(cwd, home: @home)
     end
 
-    # Project commands live under the Directory field's path, so they
-    # follow it as the defaults do.
-    def commands
-      cwd = directory
-      return @commands if @commands_for == cwd
-      @commands_for = cwd
-      @commands = SlashCommands.list(cwd: cwd, home: @home)
-    end
-
     # Full-screen body: a tall prompt editor, then one row per setting with
     # every choice visible. Exactly `height` lines.
     def screen(width, height)
@@ -192,6 +179,20 @@ module ClaudeInbox
 
     private
 
+    def command_query
+      return nil unless focused.key == :prompt
+      focused.value.head[/(?:\A|\s)\/(\S*)\z/, 1]
+    end
+
+    # Project commands live under the Directory field's path, so they
+    # follow it as the defaults do.
+    def commands
+      cwd = directory
+      return @commands if @commands_for == cwd
+      @commands_for = cwd
+      @commands = SlashCommands.list(cwd: cwd, home: @home)
+    end
+
     # Esc with a prompt typed asks first, so a stray keypress can't lose it.
     def escape_pressed
       return :cancel if field(:prompt).value.empty?
@@ -219,7 +220,7 @@ module ClaudeInbox
 
     def insert(text)
       return unless editable?
-      focused.value.insert((focused.kind == :multiline) ? text : text.tr("\n", " "))
+      (focused.kind == :multiline) ? focused.value.paste(text) : focused.value.insert(text.tr("\n", " "))
     end
 
     def menu_press(name)

data/lib/claude_inbox/painter.rb

@@ -7,9 +7,8 @@ module ClaudeInbox
   # 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)
+    def initialize(out)
       @out = out
-      @cursor = cursor
       @prev = []
     end
 
@@ -17,10 +16,10 @@ module ClaudeInbox
       buf = +""
       lines.each_with_index do |line, i|
         next if @prev[i] == line
-        buf << @cursor.move_to(0, i) << line
+        buf << TTY::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 }
+        (lines.size...@prev.size).each { |i| buf << TTY::Cursor.move_to(0, i) << TTY::Cursor.clear_line }
       end
       @out.print buf unless buf.empty?
       @out.flush

data/lib/claude_inbox/paste.rb

@@ -20,6 +20,8 @@ module ClaudeInbox
       @open = nil
     end
 
+    def pasting? = !@open.nil?
+
     def feed(raw)
       out = []
       rest = raw.to_s

data/lib/claude_inbox/poller.rb

@@ -1,48 +1,46 @@
 # frozen_string_literal: true
 
+require_relative "actions"
 require_relative "sessions"
+require_relative "snapshot"
 
 module ClaudeInbox
   # Asks `claude agents` for the list off the main thread, every INTERVAL
-  # seconds and on demand, and hands what it finds to App over the shared
-  # queue: [:sessions, list] for each hand-over, [:error, msg] when a poll
-  # fails, [:notice, text] when the reaper took something. Nothing here
-  # touches App's state directly; the queue is the whole of the interface.
-  # One worker runs every poll, so two can never overlap and publish the
-  # list out of order.
+  # 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
+  # hand-over, [:error, msg] when a poll fails, [:notice, text] when the
+  # reaper took something. Between polls it applies what another front end
+  # asked for. Nothing here touches App's state directly; the queue is the
+  # whole of the interface. One worker runs every poll, so two can never
+  # overlap and publish the list out of order.
   class Poller
     INTERVAL = 4
+    ACTIONS_INTERVAL = 0.5
 
-    def initialize(client:, store:, pull_requests:, reaper:, queue:, interval: INTERVAL, clock: -> { Time.now })
+    def initialize(client:, store:, pull_requests:, reaper:, queue:, snapshot: Snapshot.disabled, actions: Actions.disabled,
+      interval: INTERVAL, clock: -> { Time.now })
       @client = client
       @clock = clock
       @store = store
       @pull_requests = pull_requests
       @reaper = reaper
       @queue = queue
+      @snapshot = snapshot
+      @actions = actions
       @interval = interval
       @wake = Queue.new
-      @paused = false
-      @lock = Mutex.new
     end
 
     def start
       return if @thread&.alive?
       soon
       @thread = Thread.new { worker }
+      @applier = Thread.new { applier }
     end
 
-    def stop = @thread&.kill
-
-    # 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
-      @lock.synchronize { @paused = false }
-      soon
+    def stop
+      @thread&.kill
+      @applier&.kill
     end
 
     def soon = @wake << true
@@ -59,35 +57,60 @@ module ClaudeInbox
       sessions = Sessions.load(client: @client, pull_requests: @pull_requests, overrides: @store.pr_overrides)
       doomed = @reaper.due(sessions, now)
       @store.hide(doomed)
-      @queue << [:sessions, sessions]
+      publish(sessions)
       reaped = []
       begin
         reaped = @reaper.sweep(sessions.select { |s| doomed.include?(s.key) }, now)
       ensure
         @store.release(doomed - reaped)
       end
-      @queue << [:sessions, sessions] if reaped != doomed
+      publish(sessions) if reaped != doomed
       @queue << [:notice, @reaper.report(reaped)] if reaped.any?
       fresh, moved = @pull_requests.refresh(sessions)
-      @queue << [:sessions, fresh] if moved
+      publish(fresh) if moved
     rescue => e
       @queue << [:error, e.message]
     end
 
+    # Applies the requests another front end left, and says whether any landed.
+    def apply
+      return false unless @actions.drain(@store) > 0
+      write_snapshot
+      true
+    end
+
     private
 
+    def publish(sessions)
+      @store.update(sessions)
+      write_snapshot
+      @queue << [:sessions, sessions]
+    end
+
+    def write_snapshot
+      now = @clock.call
+      @snapshot.write(@store.sections(now), now)
+    end
+
     # Past StandardError `once` does not catch, and a dead worker would end
     # polling with nothing on screen to say so.
     def worker
       loop do
         @wake.pop(timeout: @interval)
         @wake.clear
-        once unless paused?
+        once
       rescue SystemStackError, ScriptError, SecurityError => e
         @queue << [:error, e.message]
       end
     end
 
-    def paused? = @lock.synchronize { @paused }
+    def applier
+      loop do
+        sleep ACTIONS_INTERVAL
+        apply
+      rescue => e
+        @queue << [:error, e.message]
+      end
+    end
   end
 end

data/lib/claude_inbox/pull_requests.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
 require "json"
+require "time"
 require_relative "records"
 require_relative "subprocess"
 
 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.
-  PullRequest = Struct.new(:number, :url, :state, :title) do
+  # 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
     def short = number ? "##{number}" : url.to_s.sub(%r{\Ahttps?://(www\.)?}, "")
 
     def merged? = state == "MERGED"
@@ -19,6 +21,16 @@ module ClaudeInbox
     def resolved? = merged? || closed?
 
     def known? = !state.nil?
+
+    # Nothing more to learn: resolved, and gh has said when.
+    def final? = resolved? && !resolved_at.nil?
+
+    # Resolved before `time`, so a session started then can only have mentioned it.
+    def resolved_before?(time) = final? && resolved_at < time.to_i
+
+    # Resolved at or after `time`, which is the only kind of resolution that
+    # can answer a session started then.
+    def resolved_since?(time) = final? && resolved_at >= time.to_i
   end
 
   # Finds the PRs a session is tied to and keeps their state fresh.
@@ -34,11 +46,10 @@ module ClaudeInbox
   # State comes first from our own record of resolved PRs, then from
   # ~/.claude/gh-pr-status-cache.json (whatever Claude Code last saw), then
   # from `gh pr view` for PRs that are still open, at most once per
-  # REFRESH_AFTER. A merged or closed PR never changes again, so it is never
-  # asked about twice — and once gh has said so, it is written to
-  # RESOLVED_PATH so the next launch does not ask either. Claude Code's cache
-  # only covers PRs its own sessions opened, and a link scan picks up plenty
-  # of others.
+  # REFRESH_AFTER. A merged or closed PR never changes again, so once gh has
+  # said so, and when, it is written to RESOLVED_PATH and never asked about
+  # again. Claude Code's cache never says when, and says nothing at all about
+  # most of a link scan's PRs: it only covers PRs its own sessions opened.
   #
   # `enrich` never touches gh; it is what stands between `claude agents` and
   # the first frame. `refresh` is the slow half, one network round trip per
@@ -73,13 +84,14 @@ module ClaudeInbox
     end
 
     # Asks gh about every PR on these sessions that is due. Returns the
-    # sessions with the answers on their `prs` and whether any state changed,
-    # so the caller knows whether the list is worth publishing again.
+    # sessions with the answers on their `prs` and whether any PR changed, so
+    # 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.state != pr.state }
+          status(pr.url).tap { |now| changed = true if now != pr }
         })
       end
       [fresh, changed]
@@ -89,11 +101,11 @@ module ClaudeInbox
     def status(url)
       @mutex.synchronize do
         pr = @known[url] ||= seed(url)
-        return pr if pr.resolved? || !due?(url)
+        return pr if pr.final? || !due?(url)
         @checked_at[url] = @clock.call.to_i
         fresh = fetch(url)
         return pr unless fresh
-        remember(fresh) if fresh.resolved?
+        remember(fresh) if fresh.final?
         @known[url] = fresh
       end
     end
@@ -102,8 +114,9 @@ module ClaudeInbox
     def self.parse(url, json)
       h = JSON.parse(json)
       state = (h["state"] == "OPEN" && h["isDraft"]) ? "DRAFT" : h["state"]
-      PullRequest.new(number: h["number"], url: h["url"] || url, state: state, title: h["title"])
-    rescue JSON::ParserError
+      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)
+    rescue JSON::ParserError, ArgumentError
       nil
     end
 
@@ -126,7 +139,8 @@ module ClaudeInbox
     def seed(url)
       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"))
+      PullRequest.new(number: cached&.dig("number") || number, url: url, state: cached&.dig("state"),
+        title: cached&.dig("title"), resolved_at: cached&.dig("resolved_at"))
     end
 
     # Same shape as Claude Code's cache, so `seed` reads both alike.
@@ -140,13 +154,13 @@ module ClaudeInbox
 
     # Under @mutex.
     def remember(pr)
-      resolved[pr.url] = {"number" => pr.number, "state" => pr.state, "title" => pr.title}
+      resolved[pr.url] = {"number" => pr.number, "state" => pr.state, "title" => pr.title, "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")
+      r = Subprocess.capture(@gh, "pr", "view", url, "--json", "number,state,isDraft,title,url,closedAt")
       r.success? ? self.class.parse(url, r.out) : nil
     rescue SystemCallError
       nil

data/lib/claude_inbox/rate_limits.rb

@@ -18,9 +18,7 @@ module ClaudeInbox
     LABELS = {"five_hour" => "session", "seven_day" => "week"}.freeze
 
     # `resets_at` is when the window rolls over, or nil if the file omits it.
-    Window = Data.define(:label, :percent, :resets_at) do
-      def initialize(label:, percent:, resets_at: nil) = super
-    end
+    Window = Data.define(:label, :percent, :resets_at)
 
     def initialize(path: DEFAULT_PATH)
       @path = path