claude-inbox 0.3.0 → 0.4.0

data/lib/claude_inbox/remote/http.rb

@@ -32,7 +32,7 @@ module ClaudeInbox
       # the JSON body, and the headers that status calls for. `note`, when
       # set, is what the refusal is logged as in place of its message.
       class Error < StandardError
-        attr_reader :status, :headers, :details, :note
+        attr_reader :status, :headers, :note
 
         def initialize(status, message, headers: {}, note: nil, **details)
           super(message)
@@ -43,6 +43,10 @@ module ClaudeInbox
         end
 
         def body = {error: Http.utf8(message), **details.transform_values { |v| v.is_a?(Integer) ? v : Http.utf8(v) }}
+
+        private
+
+        attr_reader :details
       end
 
       # A request head. `headers` are keyed in lower case, and a repeated
@@ -50,12 +54,11 @@ module ClaudeInbox
       # pass for the first. The bytes read past the head stay here for the
       # body.
       class Request
-        attr_reader :verb, :path, :query, :version, :headers
+        attr_reader :verb, :path, :headers
 
-        def initialize(verb, target, version, headers, rest)
+        def initialize(verb, target, headers, rest)
           @verb = verb
-          @path, @query = target.split("?", 2)
-          @version = version
+          @path = target.split("?", 2).first
           @headers = headers
           @rest = rest
         end
@@ -88,13 +91,13 @@ module ClaudeInbox
       def self.read_head(io, deadline:)
         rest = +"".b
         line = read_line(io, rest, deadline)
-        request = line.match(%r{\A(\S+) (/\S*) HTTP/(1\.[01])\z})
+        request = line.match(%r{\A(\S+) (/\S*) HTTP/1\.[01]\z})
         raise Error.new(400, "not an HTTP/1.x request line") unless request && request[1].match?(TOKEN)
         headers = {}
         count = 0
         loop do
           line = read_line(io, rest, deadline)
-          return Request.new(request[1], request[2], request[3], headers, rest) if line.empty?
+          return Request.new(request[1], request[2], headers, rest) if line.empty?
           raise Error.new(400, "more than #{MAX_HEADERS} headers") if (count += 1) > MAX_HEADERS
           name, value = line.split(":", 2)
           raise Error.new(400, "malformed header") unless value && name.match?(TOKEN)

data/lib/claude_inbox/remote/listener.rb

@@ -109,7 +109,7 @@ module ClaudeInbox
       def self.disabled = new(client: nil, store: nil, queue: nil, pairing: nil, port: nil)
 
       # `start_options` are Start's own.
-      def initialize(client:, store:, queue:, port:, pairing: Pairing.new, lan: false, allowed_modes: DEFAULT_MODES,
+      def initialize(queue:, port:, pairing: Pairing.new, lan: false, allowed_modes: DEFAULT_MODES,
         lock_path: LOCK_PATH, fixture: false, retry_every: RETRY_EVERY, **start_options)
         @queue = queue
         @pairing = pairing
@@ -119,8 +119,7 @@ module ClaudeInbox
         @lock_path = lock_path
         @fixture = fixture
         @retry_every = retry_every
-        @start = Start.new(client: client, store: store, queue: queue, allowed_modes: allowed_modes,
-          fixture: fixture, **start_options)
+        @start = Start.new(queue: queue, allowed_modes: allowed_modes, fixture: fixture, **start_options)
         @mutex = Mutex.new
         @state = :off
         @recent = []

data/lib/claude_inbox/remote/start.rb

@@ -27,14 +27,13 @@ module ClaudeInbox
       KEYS_KEPT = 16
 
       def initialize(client:, store:, queue:, allowed_modes:, fixture: false, images_dir: Images::DEFAULT_DIR,
-        jobs_dir: JobState::DEFAULT_DIR, trust: Trust.method(:projects), settings: Settings.method(:defaults), bridge_wait: 3)
+        trust: Trust.method(:projects), settings: Settings.method(:defaults), bridge_wait: 3)
         @client = client
         @store = store
         @queue = queue
         @allowed_modes = allowed_modes
         @fixture = fixture
         @images_dir = images_dir
-        @jobs_dir = jobs_dir
         @trust = trust
         @settings = settings
         @bridge_wait = bridge_wait
@@ -192,7 +191,7 @@ module ClaudeInbox
       def remote_url(id, wait:)
         deadline = Http.monotonic + wait
         loop do
-          url = Session.new(id: id, job_state: JobState.read(id, jobs_dir: @jobs_dir)).remote_url
+          url = Session.new(id: id, job_state: JobState.read(id, jobs_dir: @client.jobs_dir)).remote_url
           return url if url || Http.monotonic >= deadline
           sleep 0.2
         end

data/lib/claude_inbox/renderer.rb

@@ -81,14 +81,14 @@ module ClaudeInbox
 
     def frame(sections, view)
       return full_screen(sections, view) if view.screen
-      width, height, now, selected = view.width, view.height, view.now, view.selected
+      width, height, selected = view.width, view.height, view.selected
       list_w = width_for_list(width, view.peek)
       view_h = Renderer.body_height(height)
       body, items =
         if view.loading
           [loading_state(list_w, view_h, view.loading, view.tick), []]
         else
-          body_lines(sections, list_w, view, now)
+          body_lines(sections, list_w, view)
         end
 
       top = clamp_top(view.top, body.size, view_h, items, selected)
@@ -243,7 +243,7 @@ module ClaudeInbox
 
     # ----- body ---------------------------------------------------------------
 
-    def body_lines(sections, width, view, now)
+    def body_lines(sections, width, view)
       lines = []
       items = []
       if sections.all.empty?
@@ -260,7 +260,7 @@ module ClaudeInbox
           next
         end
         rows.each do |row|
-          row_lines(row, name, selected, width, now, view.tick).each_with_index do |l, i|
+          row_lines(row, name, selected, width, view.now, view.tick).each_with_index do |l, i|
             lines << l
             items << ((i.zero? && row.selectable?) ? Item.new(:row, row, name) : nil)
           end

data/lib/claude_inbox/settings.rb

@@ -47,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,9 +57,15 @@ module ClaudeInbox
 
     DEFAULT_PATH = File.join(Dir.home, ".config", "claude-inbox", "state.json")
 
-    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
@@ -74,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
@@ -85,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 wake(id) = edit(id) { |e| e.wake(@clock.call) }
+    def snooze(id, choice) = edit(id, "snooze", choice: choice.to_s) { |e| e.snooze(choice, @clock.call) }
 
-    def acknowledge(id) = edit(id) { |e| e.acknowledge(@clock.call) }
+    def wake(id) = edit(id, "wake") { |e| e.wake(@clock.call) }
 
-    def settle(id) = edit(id) { |e| e.settle(@clock.call) }
+    def acknowledge(id) = edit(id, "acknowledge") { |e| e.acknowledge(@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 }
 
@@ -144,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
@@ -156,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/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/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/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.3.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"

data/mod/.claude-plugin/plugin.json

@@ -0,0 +1,20 @@
+{
+  "name": "inbox-pane",
+  "version": "0.2.0",
+  "description": "claude-inbox's sections in a pane beside the transcript, with its keys.",
+  "types": "./types/index.d.ts",
+  "userConfig": {
+    "command": {
+      "type": "string",
+      "title": "claude-inbox command",
+      "description": "The claude-inbox executable to run headless when no inbox is writing the snapshot.",
+      "default": "claude-inbox"
+    },
+    "openOnStart": {
+      "type": "boolean",
+      "title": "Open on start",
+      "description": "Open the pane when a session starts. Off, /inbox opens it.",
+      "default": true
+    }
+  }
+}

data/mod/hooks/hooks.json

@@ -0,0 +1 @@
+{ "modules": ["./register.tsx"] }