claude-inbox 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7fc36460c912469438541ba91cd22f8c3635bb3fd80b60b695afe148f8230ee0
-  data.tar.gz: 105f161459cb30bd1d3751e2a3c926225e5087279b9056bafee46474542bca0f
+  metadata.gz: 6c29f6bef2ba7ecc7f4d63161cfc064517e21f95a3a187313a1c5b882ae34786
+  data.tar.gz: 5195d163ef619f7f82a7224ca0a9b4dfe508fd23d8c1b3d87ab0a7b3b419cb28
 SHA512:
-  metadata.gz: f31e385cff9fb60a06e7bcce8ba965398491ea65c2792ce9d609654a1d0fc5b417dcd147c0962145badf49da6bb0de734a4bcbae75c7055dbb57ec6090889087
-  data.tar.gz: 889b409820e77ec9d6b4a51de365f3524eac013b55131ac8de4d2b0eae9e573ab11c9a12c5240aea0ef40c74211893240adc22283a439f187668ce48949766ce
+  metadata.gz: 9b051d9eeba2b19da5c9ced63f9dcd00030619cc4c7ac667f873da8db411ecf3c777352d2b373dfb7def00c9737c6d1ed0bc8edb0663b0a73d850c01e429d20d
+  data.tar.gz: cfe120a05f387965ba538ea48dbf726ad1bf379684b1515d213bead19d02803be8030b14abd938457671c6d80fe0d65ce1de1715632db8c304b768a5e6d46ae8

data/README.md

@@ -1,227 +1,156 @@
 # claude-inbox
 
-Inbox-style triage for Claude Code's background sessions. It reads the same
-daemon state as `claude agents`, through `claude agents --json`, and adds
-snooze, auto-settle and each session's pull request. Use it next to
-`claude agents`, not instead of it.
+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.
 
 ![claude-inbox with one working session, one snoozed and the settled section folded](docs/screenshot.png)
 
 ## Install
 
+Requires Ruby 3.2+ and `claude` on PATH.
+
 ```
 gem install claude-inbox
 claude-inbox
 ```
 
-Requires Ruby 3.2+ and a `claude` on PATH with the agents feature. Versions
-are published to rubygems and listed under GitHub Releases.
-`claude-inbox --version` prints the installed version.
-
 Put arguments you want on every launch in `~/.config/claude-inbox/config`.
 
-## Sections
+To add the pane to every Claude Code session:
 
-1. **Pinned.** Parked at the top by hand, whatever its state. `t` toggles it.
-2. **Needs you.** `blocked` or `failed`, until you attach to it.
-3. **Active.** `working`, finished but not yet settled, interactive, or a
-   needs-you session you attached to that hasn't resolved. An interactive
-   session only reports busy, idle or waiting, which show as working, done
-   and needs you. A terminal you're sitting in never settles and can't be
-   attached, peeked or stopped from here. Sub-agents and headless `claude -p`
-   runs don't show up at all.
-4. **Snoozed.** Sorted by wake time, with "until I wake it" entries last.
-   Collapsed. Enter expands it.
-5. **Settled.** Settled with `x`, or every pull request is merged or closed.
-   Collapsed. Enter expands it.
+```
+claude-inbox install
+```
+
+`claude-inbox install --force` also replaces any other copy of the pane.
+
+## Claude Code pane
+
+The same inbox as a pane inside Claude Code, docked beside the transcript in
+a fullscreen terminal.
+
+![The inbox pane docked beside a Claude Code transcript](docs/pane.png)
 
-A row with a pull request shows it after the state, as `#885 open`,
-`#885 draft`, `#885 merged` or `#885 closed`. `o` opens it in the browser.
+`/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`, `/` or `R`. `Enter` switches to the session when you
+attached through `claude-inbox`.
 
-The daemon's `working` covers two cases, and the row tells them apart. A
-spinner and `working` mean the agent is thinking. A steady `◌` and
-`idle · 1 shell` mean it stopped and is waiting on something it started, such
-as a `--watch` shell or a sub-agent. That's why a session with nothing left to
-do can sit there for an hour.
+It opens when a session starts. To stop that, set
+`pluginConfigs.inbox-pane.options.openOnStart` to `false` in
+`~/.claude/settings.json`.
 
-Under each row in Pinned, Needs you and Active is the same line
-`claude agents` prints. While blocked it's what the session waits on
-(`↳ confirm: drop the top line?`), once done it's what it produced, and
-otherwise it's the status line. A terminal you opened yourself has none, so
-it shows its directory.
+## Sections
+
+1. **Pinned.** Rows you pinned with `t`.
+2. **Needs you.** Blocked or failed sessions 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.
+   Collapsed.
 
-A session you gave a color with `/color` wears it on the label. Nothing else
-is tinted, so a blocked session still looks blocked.
+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. A steady `◌` with `idle · 1 shell` means the agent stopped and is
+waiting on a shell or sub-agent it started.
 
 ## Keys
 
-Vim bindings. Arrows work as well as `j`/`k`. In terminals that report the
-mouse, a click selects and attaches and the wheel moves the selection. Apple
-Terminal reports neither.
+Vim bindings. Arrows and the mouse work too.
 
 | Key | Action |
 |---|---|
 | `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 (full-screen handoff; `←` or `Ctrl+Z` return here), adopt a remote session, or expand Snoozed / Settled |
-| `Tab` `Shift+Tab` | jump to the next / previous section |
-| `h` | close the peek pane, else collapse the current Snoozed / Settled fold |
-| `za` `zo` `zc` | toggle / open / close the Snoozed or Settled fold under the cursor |
+| `Enter` `l` | attach (`←` or `Ctrl+Z` returns here), adopt a remote session, or expand Snoozed / Settled |
+| `Tab` `Shift+Tab` | next / previous section |
+| `h` | close the peek pane, else collapse the current fold |
+| `za` `zo` `zc` | toggle / open / close the fold under the cursor |
 | `p` | toggle the read-only peek pane |
 | `J` `K` (`Ctrl-e` `Ctrl-y`) | scroll the peek pane |
 | `n` | new session |
-| `N` | pair a phone: whether the inbox is listening, and the URL to pair with |
+| `N` | pair a phone |
 | `t` | pin / unpin |
 | `s` | snooze: `1` 15m · `2` 1h · `3` tomorrow 9am · `4` until woken |
-| `u` | wake a snoozed session now, or bring back one you settled |
-| `x` | settle a working or needs-you session by hand (returns when it changes state, unless it just finished) |
-| `a` | set a local alias (never touches the real session name) |
-| `o` | open the session's pull request in the browser |
+| `u` | wake a snoozed session, or bring back a settled one |
+| `x` | settle by hand |
+| `a` | set a local alias |
+| `o` | open the pull request in the browser |
 | `w` | open the session at claude.ai/code |
-| `P` | link a pull request by hand (empty clears; the scanned links return) |
-| `X` | stop the session (`y` to confirm) |
-| `Ctrl-x` | delete the session for good, conversation and worktree with it (`y` to confirm) |
-| `/` | filter by name, cwd, the prompt it started from, or what it is doing now; `Enter` keeps it, `Esc` clears |
+| `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 |
 | `R` | poll now |
 | `q` | quit |
 
-`X` and `Ctrl-x` both ask first and both take `y`, but they do different
-things. `X` runs `claude stop`, which ends the process and keeps the
-conversation, and `Enter` resumes it later. `Ctrl-x` runs `claude rm`, which
-deletes the session, its transcript and its worktree. Nothing resumes after
-that, so read the box before answering.
+`X` and `Ctrl-x` both ask for `y` first.
 
 ### New session
 
-`n` opens a form with prompt, name, directory, model, effort, permissions,
-worktree and Remote Control. `Tab` and `Shift+Tab` move between fields and
-`Esc` cancels. Choice fields cycle with `h` `l` or the arrows, and "default"
-shows what your settings resolve to. The directory starts as the selected
-row's, and `Tab` completes it.
+`n` opens a form for the prompt, name, directory, model, effort, permissions,
+worktree and Remote Control. `Tab` moves between fields, `Ctrl-S` starts the
+session and `Ctrl-O` starts it and attaches.
 
-`Ctrl-S` starts the session and drops you back in the inbox. `Ctrl-O` starts
-it and attaches. It runs `claude --bg "<prompt>"` in that directory with only
-the flags you changed, and the new row is selected once it shows up.
+Paste an image on macOS, or drop a file into the prompt, and refer to it as
+`[Image #1]`. Type `/` for a menu of your skills.
 
-The prompt is multi-line, and `Enter` breaks a line. Paste an image with
-`Cmd-V` (or `Ctrl-V`) or drop a file on the window, and an `[Image #1]` token
-lands at the cursor for the prompt to point at: "make the button look like
-[Image #1]". Pasted images are kept in `~/.config/claude-inbox/images/` for
-14 days. A dropped file is referenced where it is. Pasting images works on
-macOS only.
+## How sessions move
 
-Remote Control set to yes adds `--remote-control`, so the session also shows
-up at claude.ai/code and in the Claude mobile app. It defaults to yes when
-"Enable Remote Control for all sessions" is on in `/config`.
+A snoozed session wakes when its timer runs out, when you press `u`, or when
+it becomes blocked or failed.
 
-Type `/` at the start of a word for a menu of your skills and commands.
-Plugin skills appear as `plugin:name` and claude.ai's synced skills as
-`anthropic-skills:name`. `↑` `↓` choose, `Tab` or `Enter` insert, `Esc`
-closes the menu. Built-ins such as `/init` aren't listed but still work.
+Attaching to a needs-you session moves it to Active until its state changes
+again.
 
-## How sessions move
+A session settles when you press `x` or when all its pull requests are merged
+or closed. A session without a pull request only settles by hand.
 
-**Wake.** A snoozed session comes back when its timer runs out, when you
-press `u`, or when it turns blocked or failed after you snoozed it. One that
-was already blocked when you snoozed it stays snoozed, which is the point of
-snoozing. `u` also brings back a settled row.
-
-**Acknowledge.** Attaching to a needs-you session marks its state seen and
-moves it to Active. It returns to Needs you when its state changes again. A
-new prompt while still blocked doesn't count.
-
-**Settle.** A session settles when you press `x` or when every pull request
-it has is merged or closed. A hand-settled session stays put when it
-finishes, and comes back on any other state change. `failed` never settles.
-A session with no pull request never settles on its own, and one with an
-open or draft PR stays Active.
-
-**Reap.** On the next poll, the inbox deletes a background session that has
-been quiet for 14 days with `claude rm`, transcript and worktree included.
-It's the one thing here that deletes without asking. Reaping ignores Settled,
-because an open draft keeps a row in Active for ever and those are exactly
-the rows that need reaping. Idle time is the only clock.
-
-The inbox never reaps a `working` session, one that still holds a process, a
-pinned one or a snoozed one. It does reap `failed`, even though failed never
-settles. After a fortnight of not looking at it, you won't. Pin or park a
-session to keep it.
-
-Unpushed work is safe, because `claude rm` refuses a worktree with unpushed
-commits and the inbox never overrides that. Every reap adds a line to
-`~/.config/claude-inbox/reaped.log`. `CLAUDE_INBOX_NO_REAP=1` turns reaping
+The inbox deletes background sessions that have been idle for 14 days, with
+`claude rm`. Working, pinned and snoozed sessions are kept, and `claude rm`
+refuses a worktree with unpushed commits. Each deletion is logged to
+`~/.config/claude-inbox/reaped.log`. Set `CLAUDE_INBOX_NO_REAP=1` to turn it
 off.
 
 ## Remote Control
 
-A session with Remote Control on has a page at claude.ai/code, where you can
-follow and drive it from a browser or the Claude mobile app. `w` opens it,
-and the row shows `⇅` after the state. Two kinds of session have it.
-
-- A background session started with Remote Control on, from the `n` form or
-  as `claude --bg "…" --remote-control`. It behaves like any other row, and
-  keeps Remote Control across a stop and a resume.
-- A worker a `claude remote-control` server spawned when you started a
-  session from your phone. The daemon can't attach to it, so `Enter` offers
-  to adopt it. `y` ends the worker, resumes the conversation as a background
-  session under the same id with Remote Control on, and attaches. The phone
-  session you were in ends and a new one with the whole conversation takes
-  its place. The server keeps running. A worker nobody has messaged yet has
-  nothing to adopt.
+Sessions with Remote Control show `⇅`, and `w` opens them at claude.ai/code.
+A session started from your phone through `claude remote-control` can't be
+attached directly, so `Enter` offers to adopt it as a background session.
 
 ## Starting sessions from your phone
 
-With `--listen-lan`, a phone on your Wi-Fi or VPN can start sessions the way
-`n` does. It's off unless you ask for it.
+With `--listen-lan`, a phone on your network can start sessions.
 
 ![The inbox beside the phone form, pairing and then starting a session](docs/remote-start.gif)
 
-1. Start the inbox with `claude-inbox --listen-lan`, or put `--listen-lan`
-   in `~/.config/claude-inbox/config` or `export CLAUDE_INBOX_LISTEN=lan` in
-   your shell rc.
-2. Press `N`, then `c` to copy the pairing URL. Universal Clipboard takes it
-   to the phone.
-3. Open it in Safari. To keep it, tap Share, then Add to Home Screen.
-4. Open the new Inbox icon. It has its own storage, apart from Safari's, so
-   paste the pairing URL once more and tap Pair.
+1. Run `claude-inbox --listen-lan`.
+2. Press `N`, then `c` to copy the pairing URL.
+3. Open it on the phone in Safari and tap Share, then Add to Home Screen.
+4. Open the Inbox icon, paste the URL again and tap Pair.
 
-LAN mode is plain HTTP, so the token and every prompt cross the network
-readable by anyone on it. Use it only on a network you control. Anyone with
-the token can start sessions as you in your projects. If the URL leaks, press
-`r` in the `N` dialog to replace it.
+LAN mode is plain HTTP. Use it only on a network you control, and press `r`
+in the `N` dialog if the URL leaks. [docs/remote-start.md](docs/remote-start.md)
+covers ssh, the JSON API and an iOS Shortcut.
 
-A remote start may use the `default`, `auto` and `plan` permission modes.
-[docs/remote-start.md](docs/remote-start.md) covers the rest, including ssh,
-the firewall prompt, the JSON API and an iOS Shortcut.
+## Pull requests
 
-## Pull request state
-
-The daemon scans each background session's transcript for PR links, so a
-session that only reviews a PR gets it too. It doesn't scan interactive
-sessions. Use `P` to link one by hand, or to fix a bad scan.
-
-The state comes from Claude Code's own cache, then from `gh pr view` at most
-once a minute per PR. Without `gh`, you only get the cached state.
+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.
 
 ## Usage bars
 
-The right end of the header shows how much of your 5-hour and 7-day rate
-limit windows you've used. Each is a ten-cell bar that turns yellow at 70%
-and red at 90%.
+The header can show your 5-hour and 7-day rate limit usage:
 
 ```
 session ██░░░░░░░░ 24% · 3h left  week ████░░░░░░ 41% · 2d left
 ```
 
-`session` is the 5-hour window and `week` the 7-day one, as `/usage` names
-them. `3h left` is the time until that window resets. The bars need a Pro or
-Max account and a one-time setup.
-
-Claude Code passes the numbers to your
-[status line](https://code.claude.com/docs/en/statusline) script every turn,
-and the inbox reads them from a file that script writes. Put these lines in
-the script, just after it reads stdin:
+This needs a Pro or Max account. Add these lines to your
+[status line](https://code.claude.com/docs/en/statusline) script, just after
+it reads stdin. Run `/statusline` first if you don't have one.
 
 ```bash
 input=$(cat)
@@ -229,13 +158,6 @@ limits=$(echo "$input" | jq -c '.rate_limits // empty')
 [ -n "$limits" ] && echo "$limits" > ~/.claude/rate_limits.json.tmp && mv ~/.claude/rate_limits.json.tmp ~/.claude/rate_limits.json
 ```
 
-With no status line script, run `/statusline` in any session to get one,
-then add the lines. Keep the `-n` check. A session's first status line run
-has no numbers yet, and writing anyway would blank the file.
-
-The bars stay hidden until the file exists, and hide again once it's more
-than fifteen minutes old.
-
 ## Contributing
 
 See [CONTRIBUTING.md](CONTRIBUTING.md).

data/exe/claude-inbox

@@ -8,8 +8,30 @@ if ARGV.include?("--version")
   exit
 end
 
+require "claude_inbox/mod"
+
+# The stable path to the Claude Code pane, for CLAUDE_CODE_PLUGIN_DIRS.
+if ARGV.include?("--mod-dir")
+  puts ClaudeInbox::Mod.link(force: true)
+  exit
+end
+
+if ARGV.first == "install"
+  begin
+    installed = ClaudeInbox::Mod.install(force: ARGV.include?("--force"))
+  rescue JSON::ParserError
+    abort "claude-inbox: ~/.claude/settings.json is not valid JSON, so it was left alone"
+  end
+  installed.removed.each { |dir| puts "Removed #{dir} from ~/.claude/settings.json." }
+  puts "The pane now runs #{ClaudeInbox::Mod::COMMAND || "claude-inbox from your PATH"}." if installed.command_set
+  puts installed.added ? "Added the pane to ~/.claude/settings.json. New Claude Code sessions load it; /inbox opens it." :
+    "The pane is already in ~/.claude/settings.json."
+  exit
+end
+
 require "claude_inbox/app"
 require "claude_inbox/config"
+require "claude_inbox/writer_lock"
 require "tmpdir"
 
 fixture = ARGV.include?("--fixture")
@@ -44,8 +66,30 @@ else
   opts[:client] = ClaudeInbox::AgentsClient.new
   opts[:store] = ClaudeInbox::Store.new
   opts[:reaper] = ClaudeInbox::Reaper.new(opts[:client], opts[:store])
+  opts[:snapshot] = ClaudeInbox::Snapshot.new
+  opts[:switch] = ClaudeInbox::Switch.new
+  opts[:actions] = ClaudeInbox::Actions.new
   opts[:listen] = listen
 end
 opts[:color] = false if argv.include?("--no-color")
 
+if argv.include?("--headless")
+  abort "claude-inbox: --headless takes no --fixture" if fixture
+  require "claude_inbox/headless"
+  exit(ClaudeInbox::Headless.new(client: opts[:client], store: opts[:store]).run ? 0 : 1)
+end
+
+# The first inbox you can see is the snapshot's writer: a headless one gives
+# way to it, and a second inbox reads along, writing and deleting nothing.
+# Held for the life of this process by this reference.
+writer_lock = fixture ? ClaudeInbox::WriterLock.disabled : ClaudeInbox::WriterLock.new
+unless writer_lock.take(role: "inbox")
+  opts[:store] = ClaudeInbox::Store.new(writable: false, relay: ClaudeInbox::Actions.new)
+  opts[:reaper] = ClaudeInbox::Reaper.disabled
+  opts[:snapshot] = ClaudeInbox::Snapshot.disabled
+  opts[:actions] = ClaudeInbox::Actions.disabled
+end
+# So the pane settings.json names is the installed version's, after a gem update too.
+ClaudeInbox::Mod.link unless fixture
+
 ClaudeInbox::App.new(**opts).run

data/lib/claude_inbox/actions.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module ClaudeInbox
+  # What another front end asks the inbox to do to a session: one file per
+  # request under a directory, taken and applied here, so the triage rules
+  # and the state file have one owner. A request for a session the last
+  # poll did not list waits a little, since it may have just started; one
+  # the store cannot honour after that, or a verb it lacks, is dropped.
+  class Actions
+    DEFAULT_DIR = File.join(Dir.home, ".config", "claude-inbox", "actions")
+    VERBS = %w[settle wake pin snooze acknowledge].freeze
+    SNOOZES = %w[m15 h1 tomorrow_9am until_woken].freeze
+    # A file still being written parses as nothing for milliseconds; a
+    # session not yet polled appears within one poll.
+    GRACE = 10
+
+    def self.disabled = new(dir: nil)
+
+    def initialize(dir: DEFAULT_DIR, clock: -> { Time.now })
+      @dir = dir
+      @clock = clock
+      @sent = 0
+    end
+
+    # Leaves one request for the writer, as the pane does; `from` names the
+    # asker, and a count keeps two requests in one millisecond apart.
+    def request(action, id, choice: nil, from: "inbox-#{Process.pid}")
+      return unless @dir
+      FileUtils.mkdir_p(@dir)
+      at = (@clock.call.to_f * 1000).to_i
+      request = {"action" => action, "id" => id, "at" => at}
+      request["choice"] = choice if choice
+      @sent += 1
+      File.write(File.join(@dir, "#{from}-#{at}-#{@sent}.json"), JSON.generate(request))
+    end
+
+    # 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)
+      Dir.glob(File.join(@dir, "*.json")).sort.count { |path| take(path, store, keys) }
+    end
+
+    private
+
+    # One file: false when it is left for a later pass or dropped, true once
+    # applied. Another drainer may take it first, which is nothing to report.
+    def take(path, store, keys)
+      request = parse(path)
+      return false if request.nil?
+      return false if !keys.include?(request["id"]) && young?(request)
+      File.delete(path)
+      apply(store, request, keys)
+    rescue Errno::ENOENT
+      false
+    end
+
+    # Nil leaves the file for the next pass: it is torn or early, and young.
+    def parse(path)
+      request = JSON.parse(File.read(path))
+      request = {} unless request.is_a?(Hash)
+      return request if File.mtime(path) < @clock.call - GRACE
+      (request.key?("id") && request.key?("action")) ? request : nil
+    rescue JSON::ParserError
+      (File.mtime(path) < @clock.call - GRACE) ? {} : nil
+    end
+
+    def young?(request)
+      at = request["at"].to_i / 1000
+      at.positive? && Time.at(at) >= @clock.call - GRACE
+    end
+
+    def apply(store, request, keys)
+      id = request["id"]
+      return false unless keys.include?(id) && VERBS.include?(request["action"])
+      case request["action"]
+      when "settle" then store.settle(id)
+      when "wake" then store.wake(id)
+      when "pin" then store.toggle_pin(id)
+      when "acknowledge" then store.acknowledge(id)
+      when "snooze"
+        return false unless SNOOZES.include?(request["choice"])
+        store.snooze(id, request["choice"].to_sym)
+      end
+      true
+    end
+  end
+end

data/lib/claude_inbox/agents_client.rb

@@ -3,6 +3,7 @@
 require "json"
 require_relative "debug"
 require_relative "job_state"
+require_relative "session"
 require_relative "subprocess"
 
 module ClaudeInbox
@@ -45,9 +46,11 @@ module ClaudeInbox
     # 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.
-    def attach(id)
+    # 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.
+    def attach(id, &stop)
       pid = Process.spawn(*Subprocess.command(@bin, "attach", id))
-      watchdog = Thread.new { kill_when_agents_view(pid) }
+      watchdog = Thread.new { kill_when_agents_view(pid, &stop) }
       _, status = Process.wait2(pid)
       status
     ensure
@@ -203,8 +206,6 @@ module ClaudeInbox
         pid, ppid, *cmd = l.split
         [pid.to_i, ppid.to_i, cmd.join(" ")]
       }
-    rescue Errno::ENOENT
-      []
     end
 
     # pid => command, for the given parent pids.
@@ -218,15 +219,18 @@ module ClaudeInbox
       }
     end
 
-    def kill_when_agents_view(pid)
+    def kill_when_agents_view(pid, &stop)
       loop do
         sleep WATCH_INTERVAL
         cmd = Subprocess.capture("ps", "-o", "command=", "-p", pid.to_s).out
         break if cmd.empty?
-        next unless cmd.split[1] == "agents"
+        next unless cmd.split[1] == "agents" || stop&.call
         Debug.log("watchdog saw #{cmd.inspect}")
         Process.kill("TERM", pid)
-        sleep 1
+        10.times do
+          sleep 0.1
+          break if Subprocess.capture("ps", "-o", "pid=", "-p", pid.to_s).out.empty?
+        end
         Process.kill("KILL", pid)
         break
       end