claude-inbox 0.12.2 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39ef2bafdac9f7b1c8ba1d4e6f28f5105a5fd5c42320f627caf61fd07f9c314d
-  data.tar.gz: 0ed5aadb2d02b61b1eabca62a7de74820f7e884f5ffdc6f0bbb68382ba26cc13
+  metadata.gz: f8b8a6141fcc9efc19386143e9412d4ebab669e73350ee42205e6a07fd05b290
+  data.tar.gz: 412882713110008db6ff1d96fe8b786e5d61e82ea9b349202c12560f290a86b3
 SHA512:
-  metadata.gz: 393709c2bc4fc083ded424de49ca3ad102bcf41d75fd72b5c445d8b1f23f7e80f7df0ac1623d4081994e14699168db7c58a2bc64f486b00dd83941c2d691600f
-  data.tar.gz: fb06b9a05422bff8e3a5474169a11574041219ae700e30a5178a1e507e74df95cd0c069a1c395a070a7f7856bbe6bcdd6380c2a6011a03ff36a1210c05cdae2e
+  metadata.gz: f87a453630132a470dc22b345e8f611ae0e58f04bc877c52ee1c53c4358a306377529a10ae8d807058dc32e1c9d039fc2480dd962a89d382a16e00d35faf6908
+  data.tar.gz: de74aeac784fdc777336fdaa4db38cfae93e7458873809e2c3e52c0a5a69dc53d2391cec86d73e2d52882ad9634c4567553f3d6151e2c40c571a7eca0abc8db5

data/README.md

@@ -49,7 +49,8 @@ It opens when a session starts. To stop that, set
 
 ## Sections
 
-1. **Pinned.** Rows you pinned with `t`.
+1. **Pinned.** Rows you pinned with `t`. Snoozing a pinned row moves it to
+   Snoozed, marked `★`, until it wakes back into Pinned.
 2. **Needs you.** Blocked or failed sessions, or ones whose pull request has
    failing checks or changes requested, that you haven't attached to yet.
 3. **Active.** Everything else that's running or not yet settled, including
@@ -58,6 +59,10 @@ It opens when a session starts. To stop that, set
 5. **Settled.** Settled with `x`, or every pull request is merged or closed.
    Collapsed.
 
+`--sort=activity` puts the session that spoke most recently first in every
+section but Snoozed, read from its transcript. Put it in the config file to
+keep it.
+
 Under each row is what the session is waiting on, what it produced, or its
 status line. A row with a pull request shows it as `#885 open`, `#885 merged`
 and so on, with `✗ checks`, `changes requested` or `conflicts` after it when
@@ -65,7 +70,9 @@ something is wrong, and `+2` after it when the session has two more.
 A steady `◌` with `idle · 1 shell` means the agent stopped
 and is waiting on a shell or sub-agent it started. A blue `●` marks a session you
 haven't attached to since it got blocked or finished; one you have attached
-to since is dimmed, unless `/color` tints it.
+to since is dimmed, unless `/color` tints it. The age after the badge is how
+long since the session last said anything, read from its transcript: a
+`working` row that spoke 30s ago is still talking, one silent for 2h is not.
 
 ## Keys
 
@@ -93,7 +100,7 @@ Vim bindings. Arrows and the mouse work too.
 | `P` | link a pull request by hand (empty clears) |
 | `X` | stop the session; `Enter` resumes it later |
 | `Ctrl-x` | delete the session, transcript and worktree for good |
-| `/` | filter; `Enter` keeps it, `Esc` clears |
+| `/` | filter by name, directory, prompt, status or pull request (`#885` or its title); `Enter` keeps it, `Esc` clears |
 | `R` | poll now |
 | `U` | update claude-inbox when the header says a newer one is out |
 | `q` | quit |
@@ -154,7 +161,8 @@ covers ssh, the JSON API and an iOS Shortcut.
 ## Pull requests
 
 Pull requests show up when a session's transcript links to them. Install
-`gh` to keep their state current. Use `P` to link one by hand.
+`gh` to keep their state current. Use `P` to link one by hand, and `/#885`
+to find the session behind a pull request.
 
 ## Notifications
 

data/lib/claude_inbox/actions.rb

@@ -39,7 +39,7 @@ module ClaudeInbox
     # Applies every request on disk to `store` and returns how many it took.
     def drain(store)
       return 0 unless @dir && File.directory?(@dir)
-      keys = store.sessions.select(&:actionable?).map(&:key)
+      keys = store.actionable_keys
       Dir.glob(File.join(@dir, "*.json")).sort.count { |path| take(path, store, keys) }
     end
 

data/lib/claude_inbox/agents_client.rb

@@ -27,7 +27,6 @@ module ClaudeInbox
       classify_origins(parse(r.out))
     end
 
-    # Poll interval for the agents-view watchdog below.
     WATCH_INTERVAL = 0.05
 
     # Hands the terminal to the child; caller must have restored cooked mode.
@@ -35,14 +34,11 @@ module ClaudeInbox
     # False when the attach failed on its own, as a session that cannot be
     # woken does: the CLI prints why and exits 1.
     #
-    # Pressing ← inside an attached session detaches it and then `claude
-    # attach` execs itself in place as `claude agents` (same pid). There is
-    # no flag or env var that suppresses only that relaunch: the one switch
-    # that exists disables attach too. So we watch the child's command line
-    # and, the moment it becomes the agents view, terminate it. The user then
-    # lands back in the inbox instead of native agent view.
-    # The block, polled with the command line, ends the attach early when it
-    # answers true: how a switch request from another front end is honoured.
+    # ← turns `claude attach` into `claude agents` in place, and nothing
+    # switches off only that (docs/cli-quirks.md), so the watchdog kills the
+    # child once it does. The block, polled alongside, ends the attach early
+    # when it answers true. That is how a switch request from another front
+    # end is honoured.
     def attach(id, &stop)
       pid = Process.spawn(*Subprocess.command(@bin, "attach", id))
       watchdog = Thread.new { kill_when_agents_view(pid, &stop) }
@@ -76,8 +72,7 @@ module ClaudeInbox
     # its path completion escapes them; a quoted path is not recognized.
     def self.mention(path) = "@" + path.gsub(" ", "\\ ")
 
-    # Pure so it can be tested: a setting left nil leaves its flag off. The
-    # prompt goes after "--", where a leading dash is text rather than an
+    # The prompt goes after "--", where a leading dash is text rather than an
     # unknown option, and --remote-control sits just before it: its optional
     # name would otherwise eat the prompt (both checked on 2.1.282).
     def self.spawn_args(bin, prompt:, model: nil, effort: nil, permission_mode: nil, worktree: false, name: nil, remote: false)
@@ -115,14 +110,9 @@ module ClaudeInbox
     # you type in: the headless print mode and the SDK's stream protocol.
     HEADLESS_FLAGS = %w[-p --print --input-format --output-format].freeze
 
-    # pid => origin, given `ps` for the sessions and for their parents. Pure.
-    #
-    #   :remote    a Remote Control worker: --sdk-url, or a `claude rc` parent
-    #   :headless  `claude -p "..."` or an SDK stream run. Its parent is
-    #              whatever shell spawned it, not the claude that asked for
-    #              it, so only its own command line gives it away
-    #   :subagent  parented by another claude process
-    #   :terminal  everything else, which is a claude you are sitting in
+    # pid => origin, given `ps` for the sessions and for their parents.
+    # A headless run's parent is whatever shell spawned it, not the claude
+    # that asked for it, so only its own command line gives it away.
     def self.origins(rows, parent_cmd)
       rows.to_h do |pid, ppid, cmd|
         parent = parent_cmd[ppid].to_s
@@ -143,7 +133,7 @@ module ClaudeInbox
 
     # pid => bridge session id, for the workers a `claude remote-control`
     # server spawned: each is started with `--session-id cse_…`, the same id
-    # a background session records as bridgeSessionId. Pure.
+    # a background session records as bridgeSessionId.
     def self.bridge_ids(rows)
       rows.filter_map { |pid, _, cmd| (m = cmd.match(/--session-id[= ](cse_\w+)/)) && [pid, m[1]] }.to_h
     end
@@ -185,10 +175,6 @@ module ClaudeInbox
       assign_origins(sessions, origins_from(rows), self.class.bridge_ids(rows))
     end
 
-    # Tags each interactive session with where it is driven from (pid =>
-    # origin, terminal when unlisted) and the bridge a remote one is served
-    # over, and drops the unattended ones, whose parent is the row worth
-    # showing.
     def assign_origins(sessions, origins, bridges)
       sessions
         .map { |s| s.interactive? ? s.with(origin: origins.fetch(s.pid, :terminal), bridge_id: bridges[s.pid]) : s }
@@ -259,9 +245,7 @@ module ClaudeInbox
       @bridges = bridges
     end
 
-    # Fixture rows carry no process tree; tag each interactive row from the
-    # pid => origin map the test hands in, otherwise as a terminal, then drop
-    # the unattended ones same as the real client does.
+    # Fixture rows carry no process tree.
     def list
       assign_origins(parse(File.read(@path)), @origins, @bridges)
     end

data/lib/claude_inbox/app/attaching.rb

@@ -35,7 +35,7 @@ module ClaudeInbox
           @terminal.release do
             @terminal.pause unless @client.attach(id) { @switch.requested_for?(from) }
           end
-          id = @switch.take(@store.sessions.select(&:actionable?).map(&:key))
+          id = @switch.take(@store.actionable_keys)
         end
       end
 

data/lib/claude_inbox/app.rb

@@ -47,7 +47,7 @@ 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,
+    def initialize(client: AgentsClient.new, store: Store.new, pull_requests: PullRequests.new, transcripts: Transcript.new,
       rate_limits: RateLimits.new, reaper: Reaper.disabled, snapshot: Snapshot.disabled, switch: Switch.disabled,
       actions: Actions.disabled, notifier: Notifier.disabled, listen: nil, updater: nil, argv: [], out: $stdout, input: $stdin, color: true,
       trust: Trust.method(:projects), terminal: Terminal.new(out, input), queue: Queue.new, pane_offer: Mod::Offer.disabled,
@@ -67,7 +67,7 @@ module ClaudeInbox
       @renderer = Renderer.new
       @input = Input.new(input, out)
       @queue = queue
-      @poller = Poller.new(client: client, store: store, pull_requests: pull_requests,
+      @poller = Poller.new(client: client, store: store, pull_requests: pull_requests, transcripts: transcripts,
         reaper: reaper, queue: @queue, snapshot: snapshot, actions: actions, notifier: notifier)
       @listener = listen ? Remote::Listener.new(client: client, store: store, queue: @queue, **listen) : Remote::Listener.disabled
       @selected = nil

data/lib/claude_inbox/cli.rb

@@ -59,7 +59,7 @@ module ClaudeInbox
       opts[:color] = options[:color]
       opts[:notifier] = notifier
       return opts if options[:fixture] || writer_lock.take(role: "inbox")
-      opts.merge(store: Store.new(writable: false, relay: Actions.new), reaper: Reaper.disabled,
+      opts.merge(store: Store.new(writable: false, relay: Actions.new, sort: options[:sort]), reaper: Reaper.disabled,
         snapshot: Snapshot.disabled, actions: Actions.disabled, pane_offer: Mod::Offer.disabled, notifier: Notifier.disabled)
     end
 
@@ -113,7 +113,7 @@ module ClaudeInbox
 
     def headless
       abort "claude-inbox: --headless takes no --fixture" if options[:fixture]
-      Headless.new(client: AgentsClient.new, store: Store.new, updater: updater, notifier: notifier).run
+      Headless.new(client: AgentsClient.new, store: Store.new(sort: options[:sort]), updater: updater, notifier: notifier).run
     end
 
     # Only what a check within the day already found: a cold launch never waits
@@ -132,7 +132,7 @@ module ClaudeInbox
       # token phones are paired with nor hold the real inbox's lock.
       dir = File.join(Dir.tmpdir, "claude-inbox-fixture")
       {client: FixtureClient.new(options[:fixture]),
-       store: Store.new(path: nil),
+       store: Store.new(path: nil, sort: options[:sort]),
        pull_requests: PullRequests.new(cache_path: File.join(fixtures, "gh-pr-status-cache.json"), resolved_path: nil, gh: nil),
        listen: options[:listen]&.merge(fixture: true, pairing: Remote::Pairing.new(path: File.join(dir, "listen.json")),
          lock_path: File.join(dir, "listen.lock"), images_dir: File.join(dir, "images"))}
@@ -144,7 +144,7 @@ module ClaudeInbox
     # comes only from here, and only when asked for.
     def live_options
       client = AgentsClient.new
-      store = Store.new
+      store = Store.new(sort: options[:sort])
       {client: client, store: store, reaper: options[:reap] ? Reaper.new(client, store) : Reaper.disabled,
        snapshot: Snapshot.new, switch: Switch.new, actions: Actions.new, pane_offer: Mod::Offer.new,
        listen: options[:listen], updater: updater,
@@ -162,7 +162,7 @@ module ClaudeInbox
     def writer_lock = (@lock ||= WriterLock.new)
 
     def parse(argv)
-      opts = {color: true, update_check: true}
+      opts = {color: true, update_check: true, sort: "default"}
       parser = OptionParser.new(USAGE) do |p|
         p.on("--version", "Print the version") {
           @out.puts VERSION
@@ -176,6 +176,7 @@ module ClaudeInbox
         p.on("--headless", "Keep the pane's snapshot fresh without a screen") { opts[:headless] = true }
         p.on("--reap", "Delete background sessions idle 14 days") { opts[:reap] = true }
         p.on("--no-color", "Draw without color") { opts[:color] = false }
+        p.on("--sort=ORDER", Store::SORTS, "Order every section by activity, newest message first") { |order| opts[:sort] = order }
         p.on("--notify", "Send a desktop notification when a session needs you or finishes") { opts[:notify] = true }
         p.on("--auto-update", "Install a release found today before launching") { opts[:auto_update] = true }
         p.on("--no-update-check", "Never look for a newer release") { opts[:update_check] = false }

data/lib/claude_inbox/dialog.rb

@@ -106,7 +106,8 @@ module ClaudeInbox
       # once the list spans repos.
       def label(pr)
         name = (@prs.map(&:repo).uniq.size > 1) ? pr.qualified : pr.short
-        pr.title ? @theme.pr_badge(pr, name) + @theme.dim(" · ") + pr.title : @theme.pr_badge(pr, name)
+        badge = @theme.pr_badge(pr, name)
+        pr.title ? badge + @theme.dim(" · ") + pr.title : badge
       end
     end
 

data/lib/claude_inbox/headless.rb

@@ -17,7 +17,7 @@ module ClaudeInbox
   class Headless
     RECHECK_EVERY = 60
 
-    def initialize(client:, store:, pull_requests: PullRequests.new, actions: Actions.new, snapshot: Snapshot.new,
+    def initialize(client:, store:, pull_requests: PullRequests.new, transcripts: Transcript.new, actions: Actions.new, snapshot: Snapshot.new,
       lock: WriterLock.new, updater: nil, notifier: Notifier.disabled, recheck_every: RECHECK_EVERY)
       @lock = lock
       @snapshot = snapshot
@@ -25,7 +25,7 @@ module ClaudeInbox
       @recheck_every = recheck_every
       @notice = nil
       @queue = Queue.new
-      @poller = Poller.new(client: client, store: store, pull_requests: pull_requests, reaper: Reaper.disabled,
+      @poller = Poller.new(client: client, store: store, pull_requests: pull_requests, transcripts: transcripts, reaper: Reaper.disabled,
         queue: @queue, snapshot: snapshot, actions: actions, notifier: notifier)
     end
 

data/lib/claude_inbox/images.rb

@@ -42,13 +42,12 @@ module ClaudeInbox
     # two requests saving in the same millisecond apart. Readable by the
     # owner only: a photo can be anything.
     def self.save(bytes, dir:, index:, now: Time.now)
-      data = bytes.b
-      ext = extension(data)
+      ext = extension(bytes)
       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) }
+      File.open(path, File::WRONLY | File::CREAT | File::EXCL | File::BINARY, 0o600) { |f| f.write(bytes) }
       path
     end
 

data/lib/claude_inbox/job_state.rb

@@ -8,17 +8,9 @@ module ClaudeInbox
   # ~/.claude/jobs/<id>/state.json. The only reader of that file, and the
   # only writer: a new session's color.
   #
-  # `claude agents --json` reports one word, `state`, and "working" covers two
-  # different situations: the agent is thinking, or the agent is idle and
-  # something it started earlier — a watch shell, a sub-agent — is still open.
-  # 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 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.
+  # `claude agents --json` says "working" both while the agent thinks and
+  # while it sits idle on a shell or sub-agent it started. This file tells
+  # the two apart, and holds what the JSON drops (docs/cli-quirks.md).
   #
   # Never cached. A color changes the moment you type `/color`, so every poll
   # asks the file again.
@@ -40,7 +32,7 @@ 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.
+    # does one the daemon has already forgotten.
     def self.enrich(sessions, jobs_dir:)
       sessions.map { |s| s.background? ? s.with(job_state: read(s.id, jobs_dir: jobs_dir)) : s }
     end
@@ -91,7 +83,6 @@ module ClaudeInbox
     # 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,

data/lib/claude_inbox/new_session_form.rb

@@ -42,7 +42,6 @@ module ClaudeInbox
     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)/, "~")) }
@@ -326,7 +325,7 @@ module ClaudeInbox
         f.choices.map { |c|
           text = (c == DEFAULT) ? default_text(f) : c
           if c == f.value then (on ? @theme.pill(" #{text} ", :cyan) : @theme.cyan_bold(" #{text} "))
-          elsif f.key == :color then @palette.paint(" #{text} ", c)
+          elsif f.key == :color then Palette.paint(" #{text} ", c)
           else @p.dim(" #{text} ")
           end
         }.join(" ")

data/lib/claude_inbox/palette.rb

@@ -9,7 +9,7 @@ module ClaudeInbox
   # Closing with 39 (default foreground) rather than 0 (reset everything)
   # matters: the label is often already bold or italic and a full reset
   # would strip that back off.
-  class Palette
+  module Palette
     ANSI = {
       "red" => 31, "green" => 32, "yellow" => 33,
       "blue" => 34, "purple" => 35, "cyan" => 36
@@ -22,7 +22,7 @@ module ClaudeInbox
 
     RESET = "\e[39m"
 
-    def paint(text, name)
+    def self.paint(text, name)
       seq = SEQUENCES[name]
       seq ? seq + text + RESET : text
     end

data/lib/claude_inbox/poller.rb

@@ -16,12 +16,13 @@ module ClaudeInbox
     INTERVAL = 4
     ACTIONS_INTERVAL = 0.5
 
-    def initialize(client:, store:, pull_requests:, reaper:, queue:, snapshot:, actions:,
+    def initialize(client:, store:, pull_requests:, transcripts:, reaper:, queue:, snapshot:, actions:,
       notifier: Notifier.disabled, interval: INTERVAL, clock: -> { Time.now })
       @client = client
       @clock = clock
       @store = store
       @pull_requests = pull_requests
+      @transcripts = transcripts
       @reaper = reaper
       @queue = queue
       @snapshot = snapshot
@@ -54,7 +55,7 @@ module ClaudeInbox
     # state moved.
     def once
       now = @clock.call
-      sessions = Sessions.load(client: @client, pull_requests: @pull_requests, overrides: @store.pr_overrides)
+      sessions = Sessions.load(client: @client, pull_requests: @pull_requests, transcripts: @transcripts, overrides: @store.pr_overrides)
       doomed = @reaper.due(sessions, now)
       @store.hide(doomed)
       publish(sessions)

data/lib/claude_inbox/pull_requests.rb

@@ -54,25 +54,18 @@ module ClaudeInbox
 
   # Finds the PRs a session is tied to and keeps their state fresh.
   #
-  # Claude Code already does the hard part: the daemon scans each background
-  # session's transcript for links and writes them to the session's job state
-  # 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.
+  # The links come from the daemon's scan of each background session's
+  # transcript, 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.
   #
-  # 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 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.
+  # A merged or closed PR never changes again, so once gh has said so, and
+  # when, it goes in RESOLVED_PATH and gh is never asked about it again.
+  # Claude Code's cache never says when, and only covers PRs its own
+  # sessions opened.
   #
-  # `enrich` never touches gh; it is what stands between `claude agents` and
+  # `enrich` never touches gh, since it stands between `claude agents` and
   # the first frame. `refresh` is the slow half, one network round trip per
   # open PR, and the poller calls it after the list has already gone up.
   class PullRequests
@@ -93,11 +86,10 @@ module ClaudeInbox
       @stacks = StackLinks.new
     end
 
-    # Each session with its `prs` set from what is already known, asking
-    # nobody. The scanned links come off `job_state`, so a session without
-    # one (interactive, or forgotten) has none; Sessions.load sees to the
-    # order. `overrides` maps session key => url for links set by hand; an
-    # override replaces the scanned list.
+    # Each session with its `prs` set from what is already known. The scanned
+    # links come off `job_state`, so Sessions.load reads that first.
+    # `overrides` maps session key => url for links set by hand; an override
+    # replaces the scanned list.
     def enrich(sessions, overrides)
       sessions.map do |s|
         urls = overrides[s.key] ? [overrides[s.key]] : scanned(s.job_state)
@@ -127,7 +119,7 @@ module ClaudeInbox
       end
     end
 
-    # Parse `gh pr view --json` output. Pure so it can be tested.
+    # Parse `gh pr view --json` output.
     def self.parse(url, json)
       h = JSON.parse(json)
       state = (h["state"] == "OPEN" && h["isDraft"]) ? "DRAFT" : h["state"]

data/lib/claude_inbox/reaper.rb

@@ -8,14 +8,13 @@ module ClaudeInbox
   # Reaps sessions that have sat idle past Store::REAP_AFTER.
   #
   # The one thing in the inbox that destroys anything without being asked
-  # first, so the whole of it lives here rather than spread through the poll
-  # loop, along with the append-only log that is the last record a session
-  # ever existed once `claude rm` has taken its transcript.
+  # first, so all of it lives here, along with the append-only log that is
+  # the last record a session ever existed once `claude rm` has taken its
+  # transcript.
   #
-  # Unpushed work is safe by construction. `claude rm` refuses a worktree
-  # holding commits that aren't pushed and reports a --discard-unpushed token
-  # to override it; nothing here ever passes that token, so a refusal is the
-  # end of it. Refusals are logged and retried at most daily.
+  # Unpushed work is safe: `claude rm` refuses it, and nothing here
+  # overrides that (docs/cli-quirks.md). Refusals are logged and retried at
+  # most daily.
   class Reaper
     RETRY_AFTER = 24 * 3600
     DEFAULT_LOG = File.join(Dir.home, ".config", "claude-inbox", "reaped.log")
@@ -27,14 +26,13 @@ module ClaudeInbox
       @enabled = enabled
     end
 
-    # For --fixture runs and tests: selects nothing, deletes nothing, and
-    # needs neither a client nor a store to do it.
+    # For --fixture runs and tests: selects nothing, deletes nothing.
     def self.disabled = new(nil, nil, enabled: false)
 
-    # Reaps everything due, returning the keys it actually deleted so the
-    # caller can drop those rows before they reach the store. Refusals come
-    # back as survivors rather than exceptions: one worktree with unpushed
-    # commits must not stop the rest of the sweep.
+    # Returns the keys it deleted, so the caller can drop those rows before
+    # they reach the store. Refusals come back as survivors rather than
+    # exceptions: one worktree with unpushed commits must not stop the rest
+    # of the sweep.
     #
     # Raises if the log cannot be opened, before anything is deleted. No
     # audit trail, no reaping.

data/lib/claude_inbox/remote/http.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../text"
+
 module ClaudeInbox
   module Remote
     # The little of HTTP/1.1 the listener speaks: one request per
@@ -42,7 +44,10 @@ module ClaudeInbox
           @details = details
         end
 
-        def body = {error: Http.utf8(message), **details.transform_values { |v| v.is_a?(Integer) ? v : Http.utf8(v) }}
+        # The JSON generator warns on stderr, which is the terminal, about a
+        # binary string and raises on a bad byte, and a message can quote CLI
+        # output or request bytes.
+        def body = {error: Text.utf8(message), **details.transform_values { |v| v.is_a?(Integer) ? v : Text.utf8(v) }}
 
         private
 
@@ -80,11 +85,6 @@ module ClaudeInbox
 
       def self.monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
-      # The JSON generator warns on stderr, which is the terminal, about a
-      # binary string and raises on a bad byte, and a message can quote CLI
-      # output or request bytes.
-      def self.utf8(text) = String.new(text.to_s, encoding: Encoding::UTF_8).scrub("\uFFFD")
-
       # `deadline` (on the monotonic clock) bounds the whole head, not each
       # read: a per-read timeout lets a byte every few seconds hold the
       # connection for ever.

data/lib/claude_inbox/remote/start.rb

@@ -158,7 +158,7 @@ module ClaudeInbox
         values[:prompt] = SessionRequest.attach(values[:prompt], paths)
         values, note = SessionRequest.without_stray_worktree(values)
         @queue << [:notice, "remote: starting session…"]
-        id = Http.utf8(@spawn_lock.synchronize { @client.spawn(**values) })
+        id = Text.utf8(@spawn_lock.synchronize { @client.spawn(**values) })
         url = remote_url(id, wait: values[:remote] ? @bridge_wait : 0)
         @queue << [:remote_started, id, via, note].compact
         {id: id, name: values[:name], cwd: values[:cwd], url: url}.merge(note ? {note: note} : {})

data/lib/claude_inbox/renderer.rb

@@ -65,7 +65,6 @@ module ClaudeInbox
     def initialize(home: Dir.home)
       @p = Pastel.new(enabled: true)
       @theme = Theme.new
-      @palette = Palette.new
       @home = home
     end
 
@@ -354,7 +353,7 @@ module ClaudeInbox
         elsif bold then @p.bold(label)
         else label
         end
-      @palette.paint(styled, row.session.color)
+      Palette.paint(styled, row.session.color)
     end
 
     def glyph_for(s, section, tick)
@@ -375,16 +374,17 @@ module ClaudeInbox
       base =
         case section
         when :snoozed
-          row.parked? ? @theme.purple("parked") : @theme.purple("wakes in #{Text.age(row.wake_at.to_i - now.to_i)}")
+          wake = row.parked? ? @theme.purple("parked") : @theme.purple("wakes in #{Text.age(row.wake_at.to_i - now.to_i)}")
+          row.pinned? ? wake + @theme.cyan(" ★") : wake
         when :settled
-          @p.dim("#{s.state} · #{Text.age(now.to_i - row.state_since.to_i)}")
+          @p.dim("#{s.state} · #{Text.age(now.to_i - row.spoke_at)}")
         else
           if s.interactive?
             where = s.remote? ? "remote" : "your terminal"
-            age = row.state_since ? Text.age(now.to_i - row.state_since.to_i) : Text.age(now - s.started_at)
+            age = Text.age(now.to_i - row.spoke_at)
             state_badge(s) + @p.dim(" · #{where} · #{age}")
           else
-            age = row.state_since ? @p.dim(" · " + Text.age(now.to_i - row.state_since.to_i)) : ""
+            age = @p.dim(" · " + Text.age(now.to_i - row.spoke_at))
             remote = s.remote_control? ? @theme.blue(" ⇅") : ""
             state_badge(s) + remote + age
           end

data/lib/claude_inbox/session.rb

@@ -10,7 +10,7 @@ module ClaudeInbox
   # move under it.
   Session = Data.define(
     :id, :cwd, :kind, :started_at, :session_id, :name,
-    :state, :pid, :status, :waiting_for, :origin, :prs, :job_state, :bridge_id
+    :state, :pid, :status, :waiting_for, :origin, :prs, :job_state, :bridge_id, :last_message_at
   ) do
     # Every member is optional so the parser and the specs name only what they
     # have; prs is [] rather than nil so nobody asks whether PullRequests has run.

data/lib/claude_inbox/sessions.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "job_state"
+require_relative "transcript"
 
 module ClaudeInbox
   # Puts the list together. JobState goes before PullRequests because the PR
@@ -9,8 +10,9 @@ module ClaudeInbox
   module Sessions
     module_function
 
-    def load(client:, pull_requests:, overrides:)
+    def load(client:, pull_requests:, transcripts:, overrides:)
       sessions = JobState.enrich(client.list, jobs_dir: client.jobs_dir)
+      sessions = transcripts.enrich(sessions)
       pull_requests.enrich(sessions, overrides)
     end
   end

data/lib/claude_inbox/snapshot.rb

@@ -45,6 +45,7 @@ module ClaudeInbox
       {
         "id" => row.key, "session" => s.session_id, "label" => row.label, "state" => s.effective_state, "actionable" => s.actionable?,
         "waiting" => s.waiting_on_work? || nil, "unread" => row.unread? || nil, "line" => s.summary, "wake_at" => row.wake_at, "remote" => s.remote_url, "color" => s.color,
+        "last_message_at" => s.last_message_at&.to_i,
         "pr" => pr && {"short" => pr.short, "state" => pr.state&.downcase, "url" => pr.url}
       }.compact
     end

data/lib/claude_inbox/store/entry.rb

@@ -26,11 +26,7 @@ module ClaudeInbox
         when Integer then choice
         when :m15 then now.to_i + 15 * 60
         when :h1 then now.to_i + 3600
-        when :tomorrow_9am
-          t = Time.at(now.to_i)
-          t9 = Time.new(t.year, t.month, t.day, 9, 0, 0, t.utc_offset)
-          t9 += 86_400 if t9 <= t
-          t9.to_i
+        when :tomorrow_9am then SnoozeTime.parse("9am", now)
         when :until_woken then UNTIL_WOKEN
         else raise ArgumentError, "unknown snooze #{choice.inspect}"
         end
@@ -50,8 +46,6 @@ module ClaudeInbox
 
       def parked? = wake_at == UNTIL_WOKEN
 
-      def snoozed_at = @h["snoozed_at"]
-
       def last_state = @h["last_state"]
 
       def state_since = @h["state_since"]
@@ -82,6 +76,9 @@ module ClaudeInbox
       def observe(session, now)
         now_i = now.to_i
         if last_state != session.effective_state
+          # Only a change of state wakes a snooze early, not trouble on the
+          # PR: a session blocked when you snoozed it stays snoozed.
+          @h.delete("wake_at") if last_state && session.needs_you?
           @h["last_state"] = session.effective_state
           @h["state_since"] = now_i
         end
@@ -96,7 +93,6 @@ module ClaudeInbox
         @h["last_seen"] = now_i
         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") unless row.hand_settled?
         @h.delete("acknowledged_at") unless row.acknowledged?
         @h.delete("revived_at") unless row.revived?
@@ -105,13 +101,11 @@ module ClaudeInbox
 
       def snooze(choice, now)
         @h["wake_at"] = self.class.snooze_until(choice, now)
-        @h["snoozed_at"] = now.to_i
       end
 
       # Also lifts a hand-settle and a PR settle, so `u` undoes `x` and a resolved PR alike.
       def wake(now)
         @h.delete("wake_at")
-        @h.delete("snoozed_at")
         @h.delete("settled_at")
         @h["revived_at"] = now.to_i
       end
@@ -121,7 +115,6 @@ module ClaudeInbox
       def settle(now)
         @h["settled_at"] = now.to_i
         @h.delete("wake_at")
-        @h.delete("snoozed_at")
         @h.delete("revived_at")
       end
 

data/lib/claude_inbox/store/row.rb

@@ -19,6 +19,10 @@ module ClaudeInbox
 
       def state_since = entry&.state_since
 
+      # When the session last said anything, as its transcript has it; the
+      # inbox's own clock, then the process start, when there is none to ask.
+      def spoke_at = session.last_message_at&.to_i || state_since || session.started_at&.to_i || 0
+
       def pinned_at = entry&.pinned_at
 
       def pinned? = entry&.pinned?
@@ -26,20 +30,17 @@ module ClaudeInbox
       def reap_failed_at = entry&.reap_failed_at
 
       # Names get shortened and forgotten, so the filter also reads what the
-      # session was asked to do and what it says it is doing now.
+      # session was asked to do, what it says it is doing now, and the pull
+      # requests linked to it, so `#885` finds the session behind a review.
       def matches?(query)
         q = query.downcase
-        [label, session.cwd, session.intent, session.summary].any? { |field| field.to_s.downcase.include?(q) }
+        prs = session.prs.flat_map { |pr| [pr.qualified, pr.url, pr.title] }
+        [label, session.cwd, session.intent, session.summary, *prs].any? { |field| field.to_s.downcase.include?(q) }
       end
 
-      # A session already blocked when you snoozed it stays snoozed; one that
-      # *becomes* blocked or fails afterwards wakes early.
-      def woken?(now)
-        return false if wake_at.nil?
-        return true if session.needs_you? && entry.state_since.to_i > entry.snoozed_at.to_i
-        return false if parked?
-        wake_at.to_i <= now.to_i
-      end
+      # Its timer has run out. Becoming blocked or failed wakes it sooner,
+      # but only Entry#observe sees that change happen.
+      def woken?(now) = !wake_at.nil? && !parked? && wake_at.to_i <= now.to_i
 
       def snoozed?(now) = wake_at && !woken?(now)
 
@@ -108,10 +109,11 @@ module ClaudeInbox
       end
 
       # The terminal outranks everything: never settle or hide a session you are in.
+      # A snooze outranks the pin, which stays put and returns when it wakes.
       def section(now)
         if session.terminal? then session.needs_you? ? :needs_you : :active
-        elsif pinned? then :pinned
         elsif snoozed?(now) then :snoozed
+        elsif pinned? then :pinned
         elsif !revived? && settled? then :settled # a resolved PR outranks Needs You
         elsif session.needs_you? || pr_needs_you? then acknowledged? ? :active : :needs_you
         else :active

data/lib/claude_inbox/store.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "records"
+require_relative "snooze_time"
 require_relative "store/entry"
 require_relative "store/row"
 require_relative "store/selection"
@@ -40,7 +41,13 @@ module ClaudeInbox
       Row.new(session: session, entry: hash && Entry.new(hash))
     end
 
-    def self.sectionize(sessions, entries, now)
+    # `activity` puts the session that spoke most recently first in every
+    # section but Snoozed, which stays in wake order. The default keeps each
+    # section's own order: Pinned by pin, Needs You and Settled by the state
+    # clock, Active by start with running sessions first.
+    SORTS = %w[default activity].freeze
+
+    def self.sectionize(sessions, entries, now, sort: "default")
       sec = Sections.new(pinned: [], needs_you: [], active: [], snoozed: [], settled: [])
       sessions.each do |s|
         row = row_for(s, entries)
@@ -51,6 +58,7 @@ module ClaudeInbox
       sec.active.sort_by! { |r| [r.session.finished? ? 1 : 0, -(r.session.started_at&.to_i || 0)] }
       sec.snoozed.sort_by! { |r| r.parked? ? [1, 0] : [0, r.wake_at.to_i] }
       sec.settled.sort_by! { |r| -(r.state_since || 0) }
+      %i[pinned needs_you active settled].each { |name| sec[name].sort_by! { |r| -r.spoke_at } } if sort == "activity"
       sec
     end
 
@@ -60,9 +68,10 @@ module ClaudeInbox
     # second inbox open at once, which reads along with the first rather
     # than overwriting what it and the pane's requests settled, and sends
     # its own edits to the first through the `relay` as requests.
-    def initialize(path: DEFAULT_PATH, clock: -> { Time.now }, writable: true, relay: nil)
+    def initialize(path: DEFAULT_PATH, clock: -> { Time.now }, writable: true, relay: nil, sort: "default")
       @path = path
       @clock = clock
+      @sort = sort
       @writable = writable
       @relay = relay
       @mutex = Mutex.new
@@ -86,11 +95,13 @@ module ClaudeInbox
     end
 
     def sections(now = @clock.call)
-      @mutex.synchronize { self.class.sectionize(@sessions, @entries, now) }
+      @mutex.synchronize { self.class.sectionize(@sessions, @entries, now, sort: @sort) }
     end
 
     def sessions = @mutex.synchronize { @sessions.dup }
 
+    def actionable_keys = sessions.select(&:actionable?).map(&:key)
+
     def writable? = @writable
 
     def snooze(id, choice) = edit(id, "snooze", choice: choice.to_s) { |e| e.snooze(choice, @clock.call) }

data/lib/claude_inbox/text.rb

@@ -15,11 +15,12 @@ module ClaudeInbox
 
     def strip_ansi(s) = s.gsub(ANSI, "")
 
+    # Bytes that aren't UTF-8 become U+FFFD.
+    def utf8(s) = String.new(s.to_s, encoding: Encoding::UTF_8).scrub("\uFFFD")
+
     # Control characters as \xNN, so quoted text can't reach the terminal
-    # as an escape. Bytes that aren't UTF-8 become U+FFFD.
-    def printable(s)
-      String.new(s.to_s, encoding: Encoding::UTF_8).scrub("\uFFFD").gsub(/[[:cntrl:]]/) { |c| format("\\x%02x", c.ord) }
-    end
+    # as an escape.
+    def printable(s) = utf8(s).gsub(/[[:cntrl:]]/) { |c| format("\\x%02x", c.ord) }
 
     def width(s) = Unicode::DisplayWidth.of(strip_ansi(s))
 

data/lib/claude_inbox/text_buffer.rb

@@ -3,16 +3,14 @@
 require_relative "text"
 
 module ClaudeInbox
-  # One editable string with a cursor in it. Every edit and all the cursor
-  # arithmetic live here, so callers never index into the text themselves:
-  # they hand over keypresses and ask for something to draw.
+  # One editable string with a cursor in it. Callers hand over keypresses
+  # and ask for something to draw; they never index into the text.
   #
   # Positions count cells, not bytes or characters. A cell is a grapheme
-  # cluster — prompts and session names carry emoji, and character indexes
-  # cut them in half — or a chip: an attached Image or a long Pasted text,
-  # each shown as one token (`[Image #1]`, `[Pasted text #1 +40 lines]`)
-  # that moves and deletes as one unit, the way Claude Code's own prompt
-  # treats them.
+  # cluster, since prompts and session names carry emoji that character
+  # indexes cut in half. Or it is a chip, an attached Image or a long Pasted
+  # text shown as one token (`[Image #1]`, `[Pasted text #1 +40 lines]`)
+  # that moves and deletes as one unit, as in Claude Code's own prompt.
   #
   #   b = TextBuffer.new("ab")
   #   b.press(:left, "\e[D")
@@ -56,14 +54,13 @@ module ClaudeInbox
       }.join
     end
 
-    # Swaps the whole text out and parks the cursor at the end — what
-    # completion wants after it extends a path.
+    # The cursor ends up at the end, where completion wants it after it
+    # extends a path.
     def replace(text)
       @g = text.grapheme_clusters
       @cursor = @g.size
     end
 
-    # Everything before the cursor, as one string.
     def head = @g[0...@cursor].join
 
     # How completion drops a picked command in over the half-typed one.
@@ -165,7 +162,7 @@ module ClaudeInbox
 
     # One entry per display row: [cells, offset of its first cell]. A
     # cursor at the end of a row that is already full has no cell of its
-    # own, so it gets a row of its own — what a terminal does when text
+    # own, so it gets a row of its own, as a terminal does when text
     # reaches the right margin.
     def wrapped(width)
       rows = logical_lines.flat_map do |line, start|
@@ -252,7 +249,6 @@ module ClaudeInbox
       @cursor = at
     end
 
-    # Back over any spaces, then over the word itself.
     def delete_word
       at = @cursor
       at -= 1 while at > 0 && @g[at - 1] == " "

data/lib/claude_inbox/transcript.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require_relative "agents_client"
+
+module ClaudeInbox
+  # A session's transcript, read from the end for when its last message was
+  # sent. Only the `user` and `assistant` records are messages: the CLI
+  # appends undated bookkeeping records long after a session has finished,
+  # so the file's mtime says nothing.
+  #
+  # Every poll asks, and a transcript that ends in a long run of other
+  # records costs a scan each time, so each file is read again only once
+  # it has grown.
+  class Transcript
+    MESSAGE_TYPES = %w[user assistant].freeze
+    CHUNK = 64 * 1024
+
+    def initialize
+      @seen = {} # path => [size, time]
+      @mutex = Mutex.new
+    end
+
+    def enrich(sessions, home: Dir.home)
+      sessions.map { |s| s.with(last_message_at: last_message_at(path_for(s, home))) }
+    end
+
+    def last_message_at(path)
+      return nil unless path
+      @mutex.synchronize do
+        size = File.size(path)
+        seen_size, at = @seen[path]
+        return at if seen_size == size
+        at = File.open(path, "rb") { |f| scan_back(f) }
+        @seen[path] = [size, at]
+        at
+      end
+    rescue SystemCallError
+      nil
+    end
+
+    private
+
+    def path_for(session, home)
+      session.job_state&.transcript_path ||
+        (session.cwd && session.session_id && AgentsClient.transcript_path(session.cwd, session.session_id, home: home))
+    end
+
+    def scan_back(file)
+      pos = file.size
+      carry = +""
+      while pos > 0
+        step = [CHUNK, pos].min
+        pos -= step
+        file.seek(pos)
+        lines = (file.read(step) + carry).split("\n", -1)
+        carry = pos.zero? ? +"" : lines.shift
+        lines.reverse_each do |line|
+          at = message_time(line)
+          return at if at
+        end
+      end
+      nil
+    end
+
+    def message_time(line)
+      return nil unless MESSAGE_TYPES.any? { |type| line.include?("\"type\":\"#{type}\"") }
+      record = JSON.parse(line.force_encoding(Encoding::UTF_8))
+      return nil unless MESSAGE_TYPES.include?(record["type"]) && record["timestamp"]
+      Time.iso8601(record["timestamp"])
+    rescue JSON::ParserError, ArgumentError
+      nil
+    end
+  end
+end

data/lib/claude_inbox.rb

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

data/mod/hooks/register.tsx

@@ -38,6 +38,7 @@ export type SnapshotRow = {
   unread?: boolean
   line?: string
   wake_at?: number | 'until_woken'
+  last_message_at?: number
   remote?: string
   color?: string
   pr?: { short?: string; state?: string; url?: string }
@@ -142,6 +143,7 @@ export function rowOf(section: Section, one: SnapshotRow): InboxRow {
     isUnread: one.unread === true,
     line: one.line,
     wakeAt: one.wake_at,
+    lastMessageAt: one.last_message_at,
     remote: one.remote,
     color: one.color,
     pr,
@@ -155,7 +157,10 @@ function wakeLabel(wakeAt: number | 'until_woken'): string {
 }
 
 function ago(seconds: number): string {
-  return seconds < 60 ? 'just now' : `${Math.floor(seconds / 60)}m ago`
+  if (seconds < 60) return 'just now'
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`
+  if (seconds < 86_400) return `${Math.floor(seconds / 3600)}h ago`
+  return `${Math.floor(seconds / 86_400)}d ago`
 }
 
 async function inboxFile($: EngineInterface, path: string): Promise<string> {
@@ -337,7 +342,8 @@ export const register: Register = (on, options) => {
     const chord = await read($, pending)
     const written = await read($, writtenAt)
     const release = await read($, newer)
-    const ageS = (await nowS($)) - written
+    const now = await nowS($)
+    const ageS = now - written
     const groups = groupsOf(list, folded, viewing)
     const flat = groups.flatMap(group => group.items)
     const at = onList(flat, await read($, cursor))
@@ -497,6 +503,11 @@ export const register: Register = (on, options) => {
                         </Text>
                       </Box>
                     ) : null}
+                    {one.lastMessageAt !== undefined ? (
+                      <Box flexShrink={0}>
+                        <Text dimColor> {ago(now - one.lastMessageAt)}</Text>
+                      </Box>
+                    ) : null}
                   </Box>
                   {!isQuiet && one.line !== undefined ? (
                     <Box paddingLeft={4}>

data/mod/tests/contract.test.tsx

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

data/mod/tests/pane.test.tsx

@@ -87,6 +87,18 @@ test('a poll takes the notice from the snapshot', async ($, on) => {
   expect(set.update).toBe('v0.6.0 available')
 })
 
+test('a row ends with how long ago its last message was sent, dimmed, and one without a transcript ends as it was', async ($, on) => {
+  mock.env(on, { HOME: '/Users/me' })
+  mock.clock(on, { now: 1_700_000_000_000 })
+  const dated = { ...ROWS[1], lastMessageAt: 1_700_000_000 - 5 * 3600 }
+  on('state.get', ($, e, next) => (e.key === 'rows' ? seeded([dated, ROWS[2]]) : e.key === 'writtenAt' ? seeded(1_700_000_000) : next(e)))
+  const ui = await $.ui.mount({ ...PANE, surface: 'terminal' })
+  const when = await ui.find({ type: 'Text', text: / 5h ago$/ })
+  expect(when?.props.dimColor).toBe(true)
+  expect(await ui.findAll({ type: 'Text', text: /ago$/ })).toHaveLength(1)
+  await ui.unmount()
+})
+
 test('an unread row that needs you takes the same blue dot as one that only finished', async ($, on) => {
   mock.env(on, { HOME: '/Users/me' })
   mock.clock(on, { now: 1_700_000_000_000 })

data/mod/tests/snapshot.fixture.ts

@@ -29,7 +29,8 @@ export const SNAPSHOT = `{
           "short": "#7",
           "state": "open",
           "url": "https://github.com/o/r/pull/7"
-        }
+        },
+        "last_message_at": 1789599700
       }
     ],
     "snoozed": [],

data/mod/types/index.d.ts

@@ -13,6 +13,7 @@ export type InboxRow = {
   isUnread: boolean
   line?: string
   wakeAt?: number | 'until_woken'
+  lastMessageAt?: number
   remote?: string
   color?: string
   pr?: { short: string; state: string; url: string }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: claude-inbox
 version: !ruby/object:Gem::Version
-  version: 0.12.2
+  version: 0.13.0
 platform: ruby
 authors:
 - Jordan Byron
@@ -167,6 +167,7 @@ files:
 - lib/claude_inbox/text.rb
 - lib/claude_inbox/text_buffer.rb
 - lib/claude_inbox/theme.rb
+- lib/claude_inbox/transcript.rb
 - lib/claude_inbox/trust.rb
 - lib/claude_inbox/updater.rb
 - lib/claude_inbox/vt_screen.rb