claude-inbox 0.2.0 → 0.4.0

data/lib/claude_inbox/settings.rb

@@ -7,21 +7,33 @@ module ClaudeInbox
   # settings files it reads, most specific wins. Values are strings, or
   # nil when nothing sets them — then the CLI decides at launch.
   module Settings
-    Defaults = Struct.new(:model, :effort, :permission_mode)
+    Defaults = Struct.new(:model, :effort, :permission_mode, :remote)
 
     def self.defaults(cwd, home: Dir.home)
-      layers = [
-        File.join(home, ".claude", "settings.json"),
-        File.join(cwd, ".claude", "settings.json"),
-        File.join(cwd, ".claude", "settings.local.json")
-      ].map { |path| read(path) }
+      user = read(File.join(home, ".claude", "settings.json"))
+      project = read(File.join(cwd, ".claude", "settings.json"))
+      local = read(File.join(cwd, ".claude", "settings.local.json"))
+      layers = [user, project, local]
       Defaults.new(
         model: pick(layers, "model"),
         effort: pick(layers, "effortLevel"),
-        permission_mode: pick(layers, "permissions", "defaultMode")
+        permission_mode: pick(layers, "permissions", "defaultMode"),
+        remote: remote_control(user, project, local, read(File.join(home, ".claude.json")))
       )
     end
 
+    # "Enable Remote Control for all sessions" in /config. The CLI lets a
+    # repo turn it off but only user scope turn it on, and still honours the
+    # copy older versions kept in ~/.claude.json.
+    def self.remote_control(user, project, local, legacy)
+      return "no" if project["remoteControlAtStartup"] == false || local["remoteControlAtStartup"] == false
+      [user, legacy].each do |h|
+        v = h["remoteControlAtStartup"]
+        return v ? "yes" : "no" if [true, false].include?(v)
+      end
+      nil
+    end
+
     def self.read(path)
       JSON.parse(File.read(path))
     rescue Errno::ENOENT, Errno::EACCES, JSON::ParserError
@@ -35,5 +47,6 @@ module ClaudeInbox
       end
       nil
     end
+    private_class_method :remote_control, :pick
   end
 end

data/lib/claude_inbox/slash_commands.rb

@@ -112,5 +112,6 @@ module ClaudeInbox
       s = s[1..-2] if quoted
       s.gsub("''", "'")
     end
+    private_class_method :from_dir, :skills, :commands, :qualify, :plugins, :synced, :frontmatter, :unquote
   end
 end

data/lib/claude_inbox/snapshot.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "records"
+
+module ClaudeInbox
+  # The sections as the screen shows them, written to a file for another
+  # front end to read, so the triage rules run once, here. Rewritten when
+  # the rows change and every HEARTBEAT seconds regardless, so a reader can
+  # tell a quiet inbox from one that has quit.
+  class Snapshot
+    DEFAULT_PATH = File.join(Dir.home, ".config", "claude-inbox", "snapshot.json")
+    HEARTBEAT = 5
+
+    def self.disabled = new(path: nil)
+
+    def initialize(path: DEFAULT_PATH)
+      @path = path
+      @body = nil
+      @written_at = nil
+      @mutex = Mutex.new
+    end
+
+    # Called from the poller's threads and the screen's alike.
+    def write(sections, now)
+      return unless @path
+      body = sections.to_h.to_h { |name, rows| [name.to_s, rows.map { |row| row_hash(row) }] }
+      @mutex.synchronize do
+        return if body == @body && now.to_i - @written_at < HEARTBEAT
+        @body = body
+        @written_at = now.to_i
+        Records.save(@path, {"version" => 1, "written_at" => @written_at, "sections" => body})
+      end
+    end
+
+    private
+
+    def row_hash(row)
+      s = row.session
+      pr = s.pr
+      {
+        "id" => row.key, "session" => s.session_id, "label" => row.label, "state" => s.effective_state, "actionable" => s.actionable?,
+        "waiting" => s.waiting_on_work? || nil, "terminal" => s.terminal? || nil,
+        "cwd" => s.cwd, "line" => s.summary, "wake_at" => row.wake_at, "remote" => s.remote_url,
+        "pr" => pr && {"short" => pr.short, "state" => pr.state&.downcase, "url" => pr.url}
+      }.compact
+    end
+  end
+end

data/lib/claude_inbox/store/entry.rb

@@ -69,8 +69,6 @@ module ClaudeInbox
       # When `claude rm` last refused this session, so the Reaper backs off.
       def reap_failed_at = @h["reap_failed_at"]
 
-      def reap_error = @h["reap_error"]
-
       def stale?(now) = last_seen && now.to_i - last_seen > PRUNE_AFTER
 
       def observe(session, now)

data/lib/claude_inbox/store/row.rb

@@ -66,12 +66,16 @@ module ClaudeInbox
       # Resolved PRs settle a `blocked` row too: asking "anything need
       # changing?" leaves it blocked, and merging answers it. `failed` stays
       # in view even if its PR landed; a PR nobody knows the state of yet
-      # (no gh, offline) is ignored.
+      # (no gh, offline) is ignored. So is one resolved before the session
+      # started: reviewing an old PR, or the CLI resolving a bare PR number
+      # against the wrong repo, would otherwise hide a session waiting on you.
+      # Until gh says when a PR was resolved, it holds the row in view.
       def settled?
         return true if hand_settled?
         return false if UNSETTLEABLE.include?(session.effective_state)
-        known = session.prs.select(&:known?)
-        known.any? && known.all?(&:resolved?)
+        started = session.started_at.to_i
+        ours = session.prs.select(&:known?).reject { |pr| pr.resolved_before?(started) }
+        ours.any? && ours.all? { |pr| pr.resolved_since?(started) }
       end
 
       # Idle time is the only clock, not the Settled section: the PR rule holds

data/lib/claude_inbox/store.rb

@@ -20,6 +20,7 @@ module ClaudeInbox
     # should see it, but after REAP_AFTER of not seeing it, you never will.
     UNREAPABLE = %w[working].freeze
     SECTIONS = %i[pinned needs_you active snoozed settled].freeze
+    NotWritable = Class.new(StandardError)
     # Sections long enough to be worth hiding behind a fold toggle.
     FOLDABLE_SECTIONS = %i[snoozed settled].freeze
 
@@ -56,11 +57,15 @@ module ClaudeInbox
 
     DEFAULT_PATH = File.join(Dir.home, ".config", "claude-inbox", "state.json")
 
-    attr_reader :path
-
-    def initialize(path: DEFAULT_PATH, clock: -> { Time.now })
+    # A store that is not `writable` reads the file but never saves it: the
+    # 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)
       @path = path
       @clock = clock
+      @writable = writable
+      @relay = relay
       @mutex = Mutex.new
       @sessions = []
       @hidden = Set.new
@@ -76,7 +81,7 @@ module ClaudeInbox
         @hidden &= keys
         @forgotten &= keys
         @sessions = sessions.reject { |s| @hidden.include?(s.key) || @forgotten.include?(s.key) }
-        @entries = self.class.merge_entries(@entries, @sessions, @clock.call)
+        @entries = self.class.merge_entries(@writable ? @entries : load, @sessions, @clock.call)
         save
       end
     end
@@ -87,17 +92,19 @@ module ClaudeInbox
 
     def sessions = @mutex.synchronize { @sessions.dup }
 
-    def snooze(id, choice) = edit(id) { |e| e.snooze(choice, @clock.call) }
+    def writable? = @writable
+
+    def snooze(id, choice) = edit(id, "snooze", choice: choice.to_s) { |e| e.snooze(choice, @clock.call) }
 
-    def wake(id) = edit(id) { |e| e.wake(@clock.call) }
+    def wake(id) = edit(id, "wake") { |e| e.wake(@clock.call) }
 
-    def acknowledge(id) = edit(id) { |e| e.acknowledge(@clock.call) }
+    def acknowledge(id) = edit(id, "acknowledge") { |e| e.acknowledge(@clock.call) }
 
-    def settle(id) = edit(id) { |e| e.settle(@clock.call) }
+    def settle(id) = edit(id, "settle") { |e| e.settle(@clock.call) }
 
     def mark_reap_failed(id, message) = edit(id) { |e| e.mark_reap_failed(@clock.call, message) }
 
-    def toggle_pin(id) = edit(id) { |e| e.toggle_pin(@clock.call) }
+    def toggle_pin(id) = edit(id, "pin") { |e| e.toggle_pin(@clock.call) }
 
     def set_alias(id, name) = edit(id) { |e| e.alias = name }
 
@@ -146,11 +153,17 @@ module ClaudeInbox
 
     private
 
-    def edit(id)
+    # A store that cannot save still makes the change here, for the screen,
+    # and asks the writer for it by `action` through the relay, so the next
+    # poll finds it done rather than undone. An edit with no request form
+    # would only be undone, so it is refused outright.
+    def edit(id, action = nil, **detail)
+      raise NotWritable, "another claude-inbox owns state.json" if !@writable && action.nil?
       @mutex.synchronize do
         yield Entry.new(@entries[id] ||= Entry.blank(@clock.call).to_h)
         save
       end
+      @relay&.request(action, id, **detail) if !@writable && action
     end
 
     def load
@@ -158,7 +171,7 @@ module ClaudeInbox
     end
 
     def save
-      return unless @path
+      return unless @path && @writable
       Records.save(@path, {"version" => 1, "sessions" => @entries})
     end
   end

data/lib/claude_inbox/subprocess.rb

@@ -10,8 +10,16 @@ module ClaudeInbox
       def success? = status.success?
     end
 
+    # Children start in the environment from before Bundler, or every ruby a
+    # session runs, in any project, loads our Gemfile. Handed to exec rather
+    # than set on ENV, which the poll and background threads share.
+    CHILD_ENV = defined?(Bundler.unbundled_env) ? Bundler.unbundled_env.freeze : nil
+
     module_function
 
+    # argv as exec and Process.spawn take it, with CHILD_ENV in place of ours.
+    def command(*argv) = CHILD_ENV ? [CHILD_ENV, *argv, {unsetenv_others: true}] : argv
+
     def capture(*argv, chdir: nil)
       out_r, out_w = IO.pipe
       err_r, err_w = IO.pipe
@@ -23,7 +31,7 @@ module ClaudeInbox
         out_r.close
         err_r.close
         Dir.chdir(chdir) if chdir
-        exec(*argv)
+        exec(*command(*argv))
       rescue SystemCallError => e
         $stderr.write(e.message)
         exit! 127

data/lib/claude_inbox/switch.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "records"
+
+module ClaudeInbox
+  # A request from another front end to attach to a different session: one
+  # file, written by the asker and taken by the inbox attached to the asker's
+  # own session. Only that inbox can act on it, which is why the asker gives
+  # up on a request nobody takes, and why the request names who asked.
+  class Switch
+    DEFAULT_PATH = File.join(Dir.home, ".config", "claude-inbox", "switch.json")
+
+    def self.disabled = new(path: nil)
+
+    def initialize(path: DEFAULT_PATH)
+      @path = path
+    end
+
+    def request(id, from, now) = @path && Records.save(@path, {"id" => id, "from" => from, "at" => now.to_i})
+
+    # Whether the session `from` has asked to go elsewhere.
+    def requested_for?(from)
+      return false if @path.nil? || from.nil? || !File.exist?(@path)
+      Records.read(@path)["from"] == from
+    end
+
+    # The requested id if it is one of `attachable`, and the request is gone either way.
+    def take(attachable)
+      id = Records.read(@path)["id"]
+      clear
+      attachable.include?(id) ? id : nil
+    end
+
+    def clear
+      File.delete(@path) if @path
+    rescue Errno::ENOENT
+      nil
+    end
+  end
+end

data/lib/claude_inbox/terminal.rb

@@ -3,7 +3,7 @@
 require "io/console"
 require "tty-cursor"
 require "tty-screen"
-require_relative "renderer"
+require_relative "painter"
 
 module ClaudeInbox
   # The screen the inbox draws on: the alt screen and the mouse and wheel
@@ -40,10 +40,16 @@ module ClaudeInbox
       @size = nil
     end
 
+    # The tty's mode is kept as found, not assumed: `cooked!` sets a stock
+    # mode that differs from a shell's (istrip on, imaxbel off), and the
+    # shell inherits whatever is left on quit.
     def enter
       @out.print ALT_ON, WHEEL_KEYS_ON, MOUSE_ON, PASTE_ON, TTY::Cursor.hide, TTY::Cursor.clear_screen
       @out.flush
-      @input.raw! if @input.respond_to?(:raw!) && @input.tty?
+      if @input.respond_to?(:raw!) && @input.tty?
+        @mode = @input.console_mode
+        @input.raw!
+      end
       @restored = false
       resized
     end
@@ -52,7 +58,7 @@ module ClaudeInbox
     def restore
       return if @restored
       @restored = true
-      @input.cooked! if @input.respond_to?(:cooked!) && @input.tty?
+      @input.console_mode = @mode if @mode && @input.tty?
       @out.print TTY::Cursor.show, PASTE_OFF, MOUSE_OFF, WHEEL_KEYS_OFF, ALT_OFF
       @out.flush
     rescue

data/lib/claude_inbox/text.rb

@@ -13,6 +13,12 @@ module ClaudeInbox
 
     def strip_ansi(s) = s.gsub(ANSI, "")
 
+    # 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
+
     def width(s) = Unicode::DisplayWidth.of(strip_ansi(s))
 
     # Truncate plain (uncolored) text to `w` columns, appending an ellipsis
@@ -57,7 +63,7 @@ module ClaudeInbox
         s = truncate(strip_ansi(s), w)
         cur = width(s)
       end
-      s + (" " * (w - cur))
+      s + (" " * [w - cur, 0].max)
     end
 
     # Greedy word wrap on display width. Words wider than `w` are split.

data/lib/claude_inbox/text_buffer.rb

@@ -9,20 +9,34 @@ module ClaudeInbox
   #
   # 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 that shows as one
-  # `[Image #1]` token and moves and deletes as one unit, the way Claude
-  # Code's own prompt treats a pasted image.
+  # 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.
   #
   #   b = TextBuffer.new("ab")
   #   b.press(:left, "\e[D")
   #   b.press("X", "X")
   #   b.to_s                    # => "aXb"
   class TextBuffer
-    Chip = Struct.new(:n, :path) do
+    Image = Struct.new(:n, :path) do
       def to_s = "[Image ##{n}]"
     end
 
+    Pasted = Struct.new(:n, :text) do
+      def to_s
+        lines = text.count("\n")
+        "[Pasted text ##{n} #{(lines > 0) ? "+#{lines} lines" : "#{text.size} chars"}]"
+      end
+    end
+
+    # Past either, a paste folds into a Pasted chip: laid out in full it
+    # buries the prompt around it, and wrapping it costs every frame.
+    FOLD_CHARS = 800
+    FOLD_LINES = 10
+
     def initialize(text = "")
+      @widths = Hash.new { |h, s| h[s] = Text.width(s) }
       @g = text.grapheme_clusters
       @cursor = @g.size
     end
@@ -31,13 +45,17 @@ module ClaudeInbox
 
     def empty? = @g.empty?
 
-    # Grapheme offset of the cursor. Rendering goes through #row / #view;
-    # this is here for callers that need to reason about position (tests).
-    attr_reader :cursor
-
-    def chips = @g.grep(Chip)
-
-    def expand = @g.map { |c| c.is_a?(Chip) ? yield(c) : c }.join
+    # The text as it will be sent: a Pasted chip unfolds to its text, and
+    # the block says what each Image becomes.
+    def expand
+      @g.map { |c|
+        case c
+        when Image then yield(c)
+        when Pasted then c.text
+        else c
+        end
+      }.join
+    end
 
     # Swaps the whole text out and parks the cursor at the end — what
     # completion wants after it extends a path.
@@ -62,13 +80,13 @@ module ClaudeInbox
       @cursor += g.size
     end
 
-    # Numbered after the chips already in the text, so a second image is
+    # Chips are numbered per kind and never reused, so a second image is
     # `[Image #2]` even after the first was deleted, as Claude Code does.
-    def attach(path)
-      chip = Chip.new(@next_chip = (@next_chip || 0) + 1, path)
-      @g.insert(@cursor, chip)
-      @cursor += 1
-      chip
+    def attach(path) = place(Image.new(@images = (@images || 0) + 1, path))
+
+    def paste(text)
+      return insert(text) if text.size <= FOLD_CHARS && text.count("\n") < FOLD_LINES
+      place(Pasted.new(@pastes = (@pastes || 0) + 1, text))
     end
 
     # Handles one keypress — readline's editing keys, plus printable text —
@@ -98,12 +116,18 @@ module ClaudeInbox
     # gets plain truncated text instead.
     def row(width, cursor: nil)
       return Text.truncate(to_s, width) unless cursor
-      first = 0
-      first += 1 while width_of(@g[first...@cursor]) > width - 1
+      first = @cursor
+      used = 0
+      while first > 0 && used + cell_width(@g[first - 1]) <= width - 1
+        first -= 1
+        used += cell_width(@g[first])
+      end
       cells = []
+      used = 0
       @g[first..].each do |c|
-        break if width_of(cells) + width_of([c]) > width
+        break if used + cell_width(c) > width
         cells << c
+        used += cell_width(c)
       end
       paint(cells, @cursor - first, cursor)
     end
@@ -129,12 +153,14 @@ module ClaudeInbox
 
     private
 
-    def width_of(cells) = cells.sum { |c| Text.width(c.to_s) }
+    def width_of(cells) = cells.sum { |c| cell_width(c) }
+
+    def cell_width(cell) = @widths[cell.to_s]
 
     def paint(cells, offset, cursor, chip = nil)
       out = cells.each_with_index.map do |c, i|
         s = c.to_s
-        s = chip.call(s) if chip && c.is_a?(Chip)
+        s = chip.call(s) if chip && !c.is_a?(String)
         (i == offset) ? cursor.call(s) : s
       end
       out << cursor.call(" ") if offset && offset >= cells.size
@@ -160,29 +186,48 @@ module ClaudeInbox
 
     # Text.wrap on cells, keeping the trailing spaces the cursor may sit on:
     # a chip is one cell however wide its label, so the wrap has to measure
-    # cells rather than a joined string.
+    # cells rather than a joined string. Widths are kept running rather than
+    # re-measured per word: this runs every frame, over the whole prompt.
     def segments(cells, width)
-      return [cells] if width_of(cells) <= width
-      words = cells.slice_when { |c, _| c == " " }.to_a
       lines = []
       line = []
-      words.each do |word|
-        if !line.empty? && width_of(line) + width_of(word.reverse.drop_while { |c| c == " " }) > width
+      used = 0
+      cells.slice_when { |c, _| c == " " }.each do |word|
+        word_w = width_of(word)
+        bare_w = (word.last == " ") ? word_w - 1 : word_w
+        if !line.empty? && used + bare_w > width
           lines << line
           line = []
+          used = 0
         end
-        while width_of(word) > width
-          cut = word.size - 1
-          cut -= 1 while cut > 0 && width_of(word[0...cut]) > width
-          lines << word[0...cut]
-          word = word[cut..]
+        at = 0
+        while word_w > width
+          cut, cut_w = fit(word, at, width)
+          lines << word[at...at + cut]
+          at += cut
+          word_w -= cut_w
         end
-        line += word
+        line.concat(word[at..])
+        used += word_w
       end
       lines << line unless line.empty?
       lines
     end
 
+    # How many cells of `word` from `at` fit in `width`, and their width.
+    # Always at least one, so a glyph wider than the box still moves on.
+    def fit(word, at, width)
+      count = 0
+      used = 0
+      (at...word.size).each do |i|
+        w = cell_width(word[i])
+        break if count > 0 && used + w > width
+        count += 1
+        used += w
+      end
+      [count, used]
+    end
+
     # The newline itself belongs to the line it ends, so a cursor sitting on
     # it lands past the end of that line rather than at the start of the next.
     def logical_lines
@@ -200,6 +245,12 @@ module ClaudeInbox
 
     def cursor_row(rows) = rows.rindex { |_, start| start <= @cursor } || 0
 
+    def place(chip)
+      @g.insert(@cursor, chip)
+      @cursor += 1
+      chip
+    end
+
     def delete(at, length)
       return if at < 0 || length <= 0
       @g.slice!(at, length)

data/lib/claude_inbox/trust.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "json"
+
+module ClaudeInbox
+  # The directories whose trust dialog has been accepted, read from where
+  # the CLI keeps the answer (see docs/cli-quirks.md). For choosing which
+  # directories to offer and in what order, never as a gate: whether a
+  # session may start somewhere stays the CLI's call.
+  module Trust
+    def self.projects(path: File.join(Dir.home, ".claude.json"))
+      data = JSON.parse(File.read(path))
+      projects = data["projects"] if data.is_a?(Hash)
+      return [] unless projects.is_a?(Hash)
+      projects.filter_map do |dir, entry|
+        dir if dir.start_with?("/") && !dir.include?("\0") &&
+          entry.is_a?(Hash) && entry["hasTrustDialogAccepted"] == true
+      end
+    rescue SystemCallError, IOError, JSON::ParserError
+      []
+    end
+  end
+end

data/lib/claude_inbox/vt_screen.rb

@@ -90,7 +90,7 @@ module ClaudeInbox
       n = nums[0] || 1
       case final
       when "H", "f"
-        @row = ((nums[0] || 1) - 1).clamp(0, @rows - 1)
+        @row = (n - 1).clamp(0, @rows - 1)
         @col = ((nums[1] || 1) - 1).clamp(0, @cols - 1)
       when "A" then @row = [@row - n, 0].max
       when "B" then @row = [@row + n, @rows - 1].min

data/lib/claude_inbox/writer_lock.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module ClaudeInbox
+  # One snapshot writer per machine: the inbox you can see, else a headless
+  # one. The file names the holder's role beside its pid, so an inbox takes
+  # the lock over from a headless process, which it ends, and never from
+  # another inbox; a headless process that finds the lock held exits.
+  class WriterLock
+    DEFAULT_PATH = File.join(Dir.home, ".config", "claude-inbox", "writer.lock")
+    EVICT_TRIES = 20
+
+    def self.disabled = new(path: nil)
+
+    def initialize(path: DEFAULT_PATH)
+      @path = path
+      @file = nil
+    end
+
+    # True once held. Only a headless holder is evicted, and only by an inbox.
+    def take(role:)
+      return true unless @path
+      FileUtils.mkdir_p(File.dirname(@path))
+      file = File.open(@path, File::RDWR | File::CREAT, 0o600)
+      return hold(file, role) if file.flock(File::LOCK_EX | File::LOCK_NB)
+      holder_role, holder = file.read.split
+      return refuse(file) unless role == "inbox" && holder_role == "headless"
+      Process.kill("TERM", holder.to_i) if holder.to_i.positive? && holder.to_i != Process.pid
+      EVICT_TRIES.times do
+        return hold(file, role) if file.flock(File::LOCK_EX | File::LOCK_NB)
+        sleep 0.1
+      end
+      refuse(file)
+    rescue Errno::ESRCH, Errno::EPERM
+      # The holder the file names is gone already: the lock is free.
+      file.flock(File::LOCK_EX | File::LOCK_NB) ? hold(file, role) : refuse(file)
+    end
+
+    def held? = !@file.nil?
+
+    def release
+      @file&.close
+      @file = nil
+    end
+
+    private
+
+    # After reading the holder the position sits at the end, and truncate does
+    # not move it, so the write is rewound first or it lands after NUL padding.
+    def hold(file, role)
+      file.rewind
+      file.truncate(0)
+      file.write("#{role} #{Process.pid}")
+      file.flush
+      @file = file
+      true
+    end
+
+    def refuse(file)
+      file.close
+      false
+    end
+  end
+end

data/lib/claude_inbox.rb

@@ -1,14 +1,5 @@
 # frozen_string_literal: true
 
 module ClaudeInbox
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end
-
-require_relative "claude_inbox/palette"
-require_relative "claude_inbox/session"
-require_relative "claude_inbox/job_state"
-require_relative "claude_inbox/pull_requests"
-require_relative "claude_inbox/agents_client"
-require_relative "claude_inbox/sessions"
-require_relative "claude_inbox/store"
-require_relative "claude_inbox/reaper"