claude-inbox 0.14.3 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20f415de1f5b57baa5330a96c70bb10545c1b1885e419f4174e9a938c0d3c59f
-  data.tar.gz: 1a989c77cbb0553c63ace2b341c95a988eb1028e103c09c173bc28d14023cd14
+  metadata.gz: ab2c702ba985e433dfdef1a421fc112a430338f30e82bc0ccd60c7f3a44bc810
+  data.tar.gz: 4d89ccc91011ca3e6230ab936bd6e0e799566384942734dc47f940b9db615c4d
 SHA512:
-  metadata.gz: 251df40e737ea85313ceefc9d8dc401f61fed6af73f9d26b0b2767737c66dec57e1fd02fbc46bd057384b17475b3e76dd2de669d77c4ab534df3a2bfe1e6b67c
-  data.tar.gz: c3368aa2027a9947e09e2d29a642d6ad4884a1c77392298db820b73b69a06c5970f9a30a916224f8786664d5588b307189edcbe960d9634ea1d93d4cff06ac6d
+  metadata.gz: b551a056e1a92981e3dcd6d29a1268ea741e0156eae308006d1869f2430e14418a36b42a679fda4d497fc839a5c718a5a7ccb15a8b3ee5cdc74170182233143d
+  data.tar.gz: 8237ef30f1eaab21723588d0c3e4203471de666afb3b4163f69a9e6d4ba7201af37db1796001566c885c7fef266fafd40c095065a5e4ce5b269affdfdd7af04d

data/README.md

@@ -1,7 +1,8 @@
 # claude-inbox
 
-An inbox for Claude Code's background sessions. It lists what `claude agents`
-lists and adds snooze, settle, pinning and each session's pull request.
+An inbox for Claude Code's background sessions and Codex threads. It lists
+what `claude agents` lists and adds snooze, settle, pinning and each session's
+pull request.
 
 Inspired by [T3 Code](https://github.com/pingdotgg/t3code)'s functionality and
 inbox-style UX, I wanted a better way to manage my Claude agents, so I built
@@ -40,7 +41,7 @@ a fullscreen terminal.
 
 `/inbox` opens it, `ctrl+x tab` focuses it and `esc` leaves. The keys are the
 ones below, with `ge` for `G`, `n` `p` for `Tab` `Shift+Tab`, and no `a`,
-`P`, `X`, `Ctrl-x`, `/`, `R` or `U`, and `s` has no `5`. `Enter`, or a click on a row, switches to the
+`r`, `P`, `X`, `Ctrl-x`, `/`, `R` or `U`, and `s` has no `5`. `Enter`, or a click on a row, switches to the
 session when you attached through `claude-inbox`.
 
 It opens when a session starts. To stop that, set
@@ -55,8 +56,12 @@ It opens when a session starts. To stop that, set
    failing checks or changes requested, that you haven't attached to yet.
 3. **Active.** Everything else that's running or not yet settled, including
    interactive terminals.
-4. **Snoozed.** Sorted by wake time. Collapsed.
-5. **Settled.** Settled with `x`, or every pull request is merged or closed.
+4. **Working.** With `--fold-working`, sessions still at work, until they
+   stop or you pin them. A sub-agent still running keeps a session at work;
+   one waiting only on a shell stays in Active. Collapsed; one you start
+   with `n` lights the fold line with its name instead of opening it.
+5. **Snoozed.** Sorted by wake time. Collapsed.
+6. **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
@@ -68,7 +73,7 @@ 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
 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
+and is waiting on a shell 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. The age after the badge is how
 long since the session last said anything, read from its transcript: a
@@ -83,7 +88,7 @@ Vim bindings. Arrows and the mouse work too.
 | `j` `k` | move down / up |
 | `gg` `G` | first / last row |
 | `Ctrl-d` `Ctrl-u` | half page down / up (`Ctrl-f` `Ctrl-b` full page) |
-| `Enter` `l` | attach (`←` or `Ctrl+Z` returns here), adopt a remote session, or expand Snoozed / Settled |
+| `Enter` `l` | attach (`←` or `Ctrl+Z` returns here; in Codex, `←` at the start of the prompt), adopt a remote session, or expand Snoozed / Settled |
 | `Tab` `Shift+Tab` | next / previous section |
 | `h` | collapse the current fold |
 | `za` `zo` `zc` | toggle / open / close the fold under the cursor |
@@ -94,6 +99,7 @@ Vim bindings. Arrows and the mouse work too.
 | `u` | wake a snoozed session, or bring back a settled one |
 | `x` | settle by hand |
 | `a` | set a local alias |
+| `r` | ask Claude for a new title, kept as the alias |
 | `o` | open the pull request in the browser; with several, `o` again opens the one that matters, `1`… another |
 | `w` | open the session at claude.ai/code |
 | `y` | copy the pull request url, or the session's address; with several, `y` again copies the one that matters, `1`… another |
@@ -101,7 +107,7 @@ Vim bindings. Arrows and the mouse work too.
 | `X` | stop the session; `Enter` resumes it later |
 | `Ctrl-x` | delete the session, transcript and worktree for good |
 | `/` | filter by name, directory, prompt, status or pull request (`#885` or its title); `Enter` keeps it, `Esc` clears |
-| `R` | poll now |
+| `R` | poll now (the list also refreshes on its own when a session's status changes) |
 | `U` | update claude-inbox when the header says a newer one is out |
 | `q` | quit |
 
@@ -109,8 +115,9 @@ Vim bindings. Arrows and the mouse work too.
 
 ### New session
 
-`n` opens a form for the prompt, name, directory, model, effort, permissions,
-worktree, Remote Control and color, which tints the row as `/color` would.
+`n` opens a form for the prompt, Claude or Codex, name, directory, model,
+effort, permissions, worktree, Remote Control and color, which tints the row
+as `/color` would.
 `Tab` moves between fields, `Ctrl-S` starts the session and `Ctrl-O` starts
 it and attaches. `Option-S` or `Option-O` by mistake only says which key you
 meant; it no longer reads as `Esc` and asks to discard the prompt.

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.actionable_keys
+      keys = store.attachable_keys
       Dir.glob(File.join(@dir, "*.json")).sort.count { |path| take(path, store, keys) }
     end
 

data/lib/claude_inbox/app/attaching.rb

@@ -9,14 +9,15 @@ module ClaudeInbox
 
       def activate
         return set_expanded(true) if @selected&.fold?
-        return @modal = Dialog::Confirm.new(:adopt, @selected.key) if selected_session&.remote?
-        attach(@selected.key) if require_actionable
+        return @modal = Dialog::Confirm.new(:adopt, @selected.key) if selected_session&.can?(:adopt)
+        attach(selected_session) if allowed?(:attach)
       end
 
-      # Guard for attach/stop: refuse politely on a terminal or remote row.
-      def require_actionable
+      # Guard for attach/stop/delete: refuse politely on a terminal or remote
+      # row, and say nothing for an action the row's harness has not got.
+      def allowed?(action)
         s = selected_session
-        return true if s&.actionable?
+        return true if s&.can?(action)
         if s&.interactive?
           notice(s.remote? ? "that's a remote session — Enter adopts it, w opens it at claude.ai/code" : "that's your own terminal — switch to that window")
         end
@@ -27,49 +28,56 @@ module ClaudeInbox
       # attach ends and the next starts without passing through the list. The
       # poller keeps running meanwhile, so the pane's snapshot stays fresh. A
       # failed attach leaves its reason on screen until a key is pressed.
-      def attach(id)
-        while id
+      def attach(session)
+        while session
           @switch.clear
-          from = session_for(id)&.session_id
-          @store.visit(id) do
+          from = session.session_id
+          @store.visit(session.key) do
             @terminal.release do
-              @terminal.pause unless @client.attach(id) { @switch.requested_for?(from) }
+              @terminal.pause unless @client.attach(session) { @switch.requested_for?(from) }
             end
           end
           @poller.soon
-          id = @switch.take(@store.actionable_keys)
+          session = session_for(@switch.take(@store.attachable_keys))
         end
       end
 
+      # A session just started or adopted, which no poll has listed yet.
+      def started(id, harness: :claude, cwd: nil) = Session.new(harness: harness, id: id, cwd: cwd)
+
       def adopt_session(key)
         s = session_for(key)
-        return unless s&.remote?
+        return unless s&.can?(:adopt)
         notice("adopting #{s.display_name}…")
         in_background do
           id = @client.adopt(session_id: s.session_id, cwd: s.cwd, pid: s.pid)
           @queue << [:notice, "adopted as #{id}"]
           @queue << [:select, id]
-          @queue << [:attach, id]
+          @queue << [:attach, started(id)]
         end
       end
 
       def open_confirm(kind)
-        return unless require_actionable
-        @modal = Dialog::Confirm.new(kind, @selected.key, label_for(@selected.key))
+        return unless allowed?(kind)
+        @modal = Dialog::Confirm.new(kind, @selected.key, label_for(@selected.key), worktree: !selected_session.worktree_path.nil?)
       end
 
+      # A Codex thread between turns has nothing to stop, which is no failure.
       def stop_session(id)
+        return unless (s = session_for(id))
+        label = label_for(id)
         in_background do
-          @client.stop(id)
+          @queue << [:notice, "#{label} has no turn running"] unless @client.stop(s)
           @poller.soon
         end
       end
 
       def delete_session(id)
+        return unless (s = session_for(id))
         label = label_for(id)
         notice("deleting #{label}…")
         in_background do
-          @client.rm(id)
+          @client.rm(s)
           @store.forget(id)
           @queue << [:notice, "deleted #{label}"]
           @poller.soon

data/lib/claude_inbox/app/navigating.rb

@@ -5,21 +5,36 @@ module ClaudeInbox
     # Where the cursor is in the sectioned, foldable list and how it moves.
     # The only writer of the selection; the rest of App reads it.
     module Navigating
+      ARRIVAL_SECONDS = 4
+
       private
 
+      def arrival(now) = @arrival&.then { |a, until_at| a if now < until_at }
+
       # The row to land on once a poll lists it, as after a spawn.
       def select_later(id)
         @pending_select = id
       end
 
-      def ensure_selection(sections)
-        stops = sections.selections(@expanded)
+      # A requested row is settled the poll it first appears in, filtered
+      # out or not: left pending, it would fire whenever the row next
+      # surfaced, taking the cursor from wherever you had moved it since.
+      # Behind a fold it lights the fold line for a few seconds and leaves
+      # both the fold and the cursor alone, since a folded session is one
+      # you chose not to watch.
+      def ensure_selection(all)
+        sections = filtered(all)
         pending = @pending_select && Store::Selection.row(@pending_select)
-        if pending && stops.include?(pending)
-          select(pending)
+        if pending && all.section_of(pending)
           @pending_select = nil
-          return
+          name = sections.section_of(pending)
+          if name && Store.folded?(name, @expanded)
+            @arrival = [Renderer::Arrival.new(section: name, label: label_for(pending.key)), Time.now + ARRIVAL_SECONDS]
+          elsif name
+            return select(pending)
+          end
         end
+        stops = sections.selections(@expanded)
         return if stops.include?(@selected)
         select(stops.first)
       end
@@ -63,7 +78,6 @@ module ClaudeInbox
         select(heads[(idx + dir) % heads.size].last)
       end
 
-      # The foldable section the cursor is currently on or inside, if any.
       def current_fold_section
         name = filtered.section_of(@selected)
         name if Store::FOLDABLE_SECTIONS.include?(name)
@@ -80,9 +94,8 @@ module ClaudeInbox
 
       def toggle_expanded = set_expanded(!@expanded[current_fold_section])
 
-      # Clicking a row selects it and attaches, same as landing on it with
-      # j/k and pressing Enter — activate already knows how to expand a fold
-      # or refuse a terminal/remote row, so this doesn't repeat that.
+      # Left to activate, as Enter is, to expand a fold or refuse a
+      # terminal or remote row.
       def click_row(row)
         item = row_item_at(row)
         return unless item

data/lib/claude_inbox/app/spawning.rb

@@ -9,7 +9,7 @@ module ClaudeInbox
       def open_new_session
         cwd = selected_session&.cwd || Dir.pwd
         dirs = SessionRequest.directories(@store.sessions, @trust.call)
-        @modal = NewSessionForm.new(cwd: SessionRequest.strip_worktree(cwd), dirs: dirs)
+        @modal = NewSessionForm.new(cwd: SessionRequest.strip_worktree(cwd), dirs: dirs, choices: @client.choices)
       end
 
       # `:start`/`:start_and_attach` leave the form as `@modal`, now busy: it
@@ -35,8 +35,8 @@ module ClaudeInbox
           @queue << [:notice, ["started #{id}", note].compact.join(" — ")]
           @queue << [:form_started, form]
           @queue << [:select, id]
-          attach ? @queue << [:attach, id] : @poller.soon
-        rescue AgentsClient::Error => e
+          attach ? @queue << [:attach, started(id, harness: v[:harness], cwd: v[:cwd])] : @poller.soon
+        rescue Harnesses::Error => e
           @queue << [:form_failed, form, e.message]
         end
       end

data/lib/claude_inbox/app/triaging.rb

@@ -62,6 +62,21 @@ module ClaudeInbox
         @modal = Dialog::Prompt.new(:alias, @selected.key, current)
       end
 
+      def retitle_selected
+        return unless require_storable && require_writable("retitle")
+        key, session = @selected.key, selected_session
+        current = @store.alias_for(key) || session.display_name
+        notice("asking claude for a title…")
+        in_background do
+          title = @titler.title(session, current: current)
+          next @queue << [:notice, "“#{current}” still fits"] if title == current
+          @store.set_alias(key, title)
+          @queue << [:notice, "titled “#{title}” — a edits it"]
+        rescue Titler::Error => e
+          @queue << [:notice, e.message]
+        end
+      end
+
       def open_pr_editor
         return unless require_storable && require_writable("link a pull request")
         current = @store.pr_for(@selected.key) || selected_session&.pr&.url || ""

data/lib/claude_inbox/app.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "agents_client"
+require_relative "claude/agents_client"
+require_relative "harnesses"
 require_relative "debug"
 require_relative "dialog"
 require_relative "input"
@@ -12,6 +13,7 @@ require_relative "keymap"
 require_relative "remote/listener"
 require_relative "new_session_form"
 require_relative "pull_requests"
+
 require_relative "reaper"
 require_relative "notifier"
 require_relative "poller"
@@ -25,6 +27,7 @@ require_relative "switch"
 require_relative "trust"
 require_relative "mod"
 require_relative "updater"
+require_relative "titler"
 require_relative "app/updating"
 require_relative "app/filtering"
 require_relative "app/triaging"
@@ -47,13 +50,14 @@ 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, transcripts: Transcript.new,
+    def initialize(client: Harnesses.new(claude: Claude::AgentsClient.new), store: Store.new, pull_requests: PullRequests.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,
-      clipboard: Clipboard.method(:copy))
+      clipboard: Clipboard.method(:copy), titler: Titler.new)
       @client = client
       @clipboard = clipboard
+      @titler = titler
       @store = store
       @snapshot = snapshot
       @switch = switch
@@ -67,7 +71,7 @@ module ClaudeInbox
       @renderer = Renderer.new
       @input = Input.new(input, out)
       @queue = queue
-      @poller = Poller.new(client: client, store: store, pull_requests: pull_requests, transcripts: transcripts,
+      @poller = Poller.new(client: client, store: store, pull_requests: pull_requests,
         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
@@ -253,6 +257,7 @@ module ClaudeInbox
       when :toggle_pin then toggle_pin_selected
       when :settle then settle_selected
       when :alias then open_alias_editor
+      when :retitle then retitle_selected
       when :link_pr then open_pr_editor
       when :open_pr then open_pr
       when :open_remote then open_remote
@@ -283,13 +288,13 @@ module ClaudeInbox
       sections = filtered(all)
       width, height = @terminal.size
       body_h = Renderer.body_height(height)
-      ensure_selection(sections)
+      ensure_selection(all)
       @tick += 1
       view = Renderer::View.new(
         width: width, height: height, now: now, selected: @selected&.key, top: @frame.top, expanded: @expanded,
         modal: modal_lines(width), screen: screen_lines(width, body_h),
         status: status_text(now), usage: @rate_limits.windows(now), filter: filter, filter_editing: filter_editing?,
-        tick: @tick / 2, loading: loading_for, listening: @listener.snapshot
+        tick: @tick / 2, loading: loading_for, listening: @listener.snapshot, arrival: arrival(now)
       )
       @frame = @renderer.frame(sections, view)
       @frame = @frame.plain unless @color # --no-color: decided here and nowhere else