claude-inbox 0.3.0 → 0.5.0

data/lib/claude_inbox/poller.rb

@@ -4,45 +4,41 @@ require_relative "sessions"
 
 module ClaudeInbox
   # Asks `claude agents` for the list off the main thread, every INTERVAL
-  # seconds and on demand, and hands what it finds to App over the shared
-  # queue: [:sessions, list] for each hand-over, [:error, msg] when a poll
-  # fails, [:notice, text] when the reaper took something. Nothing here
-  # touches App's state directly; the queue is the whole of the interface.
-  # One worker runs every poll, so two can never overlap and publish the
-  # list out of order.
+  # seconds and on demand, puts what it finds in the store and the snapshot,
+  # and tells App over the shared queue: [:sessions, list] for each
+  # hand-over, [:error, msg] when a poll fails, [:notice, text] when the
+  # reaper took something. Between polls it applies what another front end
+  # asked for. Nothing here touches App's state directly; the queue is the
+  # whole of the interface. One worker runs every poll, so two can never
+  # overlap and publish the list out of order.
   class Poller
     INTERVAL = 4
+    ACTIONS_INTERVAL = 0.5
 
-    def initialize(client:, store:, pull_requests:, reaper:, queue:, interval: INTERVAL, clock: -> { Time.now })
+    def initialize(client:, store:, pull_requests:, reaper:, queue:, snapshot:, actions:,
+      interval: INTERVAL, clock: -> { Time.now })
       @client = client
       @clock = clock
       @store = store
       @pull_requests = pull_requests
       @reaper = reaper
       @queue = queue
+      @snapshot = snapshot
+      @actions = actions
       @interval = interval
       @wake = Queue.new
-      @paused = false
-      @lock = Mutex.new
     end
 
     def start
       return if @thread&.alive?
       soon
       @thread = Thread.new { worker }
+      @applier = Thread.new { applier }
     end
 
-    def stop = @thread&.kill
-
-    # Only skips polls while another process holds the terminal; a poll
-    # already under way finishes. Forking from another thread meanwhile, as
-    # a remote start does, is fine: Subprocess puts every child in its own
-    # session, away from the tty.
-    def pause = @lock.synchronize { @paused = true }
-
-    def resume
-      @lock.synchronize { @paused = false }
-      soon
+    def stop
+      @thread&.kill
+      @applier&.kill
     end
 
     def soon = @wake << true
@@ -59,35 +55,60 @@ module ClaudeInbox
       sessions = Sessions.load(client: @client, pull_requests: @pull_requests, overrides: @store.pr_overrides)
       doomed = @reaper.due(sessions, now)
       @store.hide(doomed)
-      @queue << [:sessions, sessions]
+      publish(sessions)
       reaped = []
       begin
         reaped = @reaper.sweep(sessions.select { |s| doomed.include?(s.key) }, now)
       ensure
         @store.release(doomed - reaped)
       end
-      @queue << [:sessions, sessions] if reaped != doomed
+      publish(sessions) if reaped != doomed
       @queue << [:notice, @reaper.report(reaped)] if reaped.any?
       fresh, moved = @pull_requests.refresh(sessions)
-      @queue << [:sessions, fresh] if moved
+      publish(fresh) if moved
     rescue => e
       @queue << [:error, e.message]
     end
 
+    # Applies the requests another front end left, and says whether any landed.
+    def apply
+      return false unless @actions.drain(@store) > 0
+      write_snapshot
+      true
+    end
+
     private
 
+    def publish(sessions)
+      @store.update(sessions)
+      write_snapshot
+      @queue << [:sessions, sessions]
+    end
+
+    def write_snapshot
+      now = @clock.call
+      @snapshot.write(@store.sections(now), now)
+    end
+
     # Past StandardError `once` does not catch, and a dead worker would end
     # polling with nothing on screen to say so.
     def worker
       loop do
         @wake.pop(timeout: @interval)
         @wake.clear
-        once unless paused?
+        once
       rescue SystemStackError, ScriptError, SecurityError => e
         @queue << [:error, e.message]
       end
     end
 
-    def paused? = @lock.synchronize { @paused }
+    def applier
+      loop do
+        sleep ACTIONS_INTERVAL
+        apply
+      rescue => e
+        @queue << [:error, e.message]
+      end
+    end
   end
 end

data/lib/claude_inbox/pull_requests.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
 require "json"
+require "time"
 require_relative "records"
 require_relative "subprocess"
 
 module ClaudeInbox
   # A pull request tied to a session. `state` uses GitHub's vocabulary plus
   # DRAFT, the same as Claude Code's own cache: OPEN, DRAFT, MERGED, CLOSED,
-  # or nil when nothing has told us yet.
-  PullRequest = Struct.new(:number, :url, :state, :title) do
+  # or nil when nothing has told us yet. `resolved_at` is when it was merged
+  # or closed, in epoch seconds, once gh has said.
+  PullRequest = Struct.new(:number, :url, :state, :title, :resolved_at) do
     def short = number ? "##{number}" : url.to_s.sub(%r{\Ahttps?://(www\.)?}, "")
 
     def merged? = state == "MERGED"
@@ -19,6 +21,16 @@ module ClaudeInbox
     def resolved? = merged? || closed?
 
     def known? = !state.nil?
+
+    # Nothing more to learn: resolved, and gh has said when.
+    def final? = resolved? && !resolved_at.nil?
+
+    # Resolved before `time`, so a session started then can only have mentioned it.
+    def resolved_before?(time) = final? && resolved_at < time.to_i
+
+    # Resolved at or after `time`, which is the only kind of resolution that
+    # can answer a session started then.
+    def resolved_since?(time) = final? && resolved_at >= time.to_i
   end
 
   # Finds the PRs a session is tied to and keeps their state fresh.
@@ -34,11 +46,10 @@ module ClaudeInbox
   # 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 it is never
-  # asked about twice — and once gh has said so, it is written to
-  # RESOLVED_PATH so the next launch does not ask either. Claude Code's cache
-  # only covers PRs its own sessions opened, and a link scan picks up plenty
-  # of others.
+  # 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.
   #
   # `enrich` never touches gh; it is what stands between `claude agents` and
   # the first frame. `refresh` is the slow half, one network round trip per
@@ -65,7 +76,7 @@ module ClaudeInbox
     # 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.
-    def enrich(sessions, overrides = {})
+    def enrich(sessions, overrides)
       sessions.map do |s|
         urls = overrides[s.key] ? [overrides[s.key]] : (s.job_state&.pr_urls || [])
         s.with(prs: urls.map { |u| known(u) })
@@ -73,13 +84,14 @@ module ClaudeInbox
     end
 
     # Asks gh about every PR on these sessions that is due. Returns the
-    # sessions with the answers on their `prs` and whether any state changed,
-    # so the caller knows whether the list is worth publishing again.
+    # sessions with the answers on their `prs` and whether any PR changed, so
+    # the caller knows whether the list is worth publishing again. A merge
+    # date alone counts: it is what lets a PR the cache called merged settle.
     def refresh(sessions)
       changed = false
       fresh = sessions.map do |s|
         s.with(prs: s.prs.map { |pr|
-          status(pr.url).tap { |now| changed = true if now.state != pr.state }
+          status(pr.url).tap { |now| changed = true if now != pr }
         })
       end
       [fresh, changed]
@@ -89,11 +101,11 @@ module ClaudeInbox
     def status(url)
       @mutex.synchronize do
         pr = @known[url] ||= seed(url)
-        return pr if pr.resolved? || !due?(url)
+        return pr if pr.final? || !due?(url)
         @checked_at[url] = @clock.call.to_i
         fresh = fetch(url)
         return pr unless fresh
-        remember(fresh) if fresh.resolved?
+        remember(fresh) if fresh.final?
         @known[url] = fresh
       end
     end
@@ -102,8 +114,9 @@ module ClaudeInbox
     def self.parse(url, json)
       h = JSON.parse(json)
       state = (h["state"] == "OPEN" && h["isDraft"]) ? "DRAFT" : h["state"]
-      PullRequest.new(number: h["number"], url: h["url"] || url, state: state, title: h["title"])
-    rescue JSON::ParserError
+      resolved_at = h["closedAt"] && Time.iso8601(h["closedAt"]).to_i
+      PullRequest.new(number: h["number"], url: h["url"] || url, state: state, title: h["title"], resolved_at: resolved_at)
+    rescue JSON::ParserError, ArgumentError
       nil
     end
 
@@ -126,7 +139,8 @@ module ClaudeInbox
     def seed(url)
       number = url[%r{/pull/(\d+)}, 1]&.to_i
       cached = resolved[url] || claude_cache[url]
-      PullRequest.new(number: cached&.dig("number") || number, url: url, state: cached&.dig("state"), title: cached&.dig("title"))
+      PullRequest.new(number: cached&.dig("number") || number, url: url, state: cached&.dig("state"),
+        title: cached&.dig("title"), resolved_at: cached&.dig("resolved_at"))
     end
 
     # Same shape as Claude Code's cache, so `seed` reads both alike.
@@ -140,13 +154,13 @@ module ClaudeInbox
 
     # Under @mutex.
     def remember(pr)
-      resolved[pr.url] = {"number" => pr.number, "state" => pr.state, "title" => pr.title}
+      resolved[pr.url] = {"number" => pr.number, "state" => pr.state, "title" => pr.title, "resolved_at" => pr.resolved_at}
       return unless @resolved_path
       Records.save(@resolved_path, resolved)
     end
 
     def fetch(url)
-      r = Subprocess.capture(@gh, "pr", "view", url, "--json", "number,state,isDraft,title,url")
+      r = Subprocess.capture(@gh, "pr", "view", url, "--json", "number,state,isDraft,title,url,closedAt")
       r.success? ? self.class.parse(url, r.out) : nil
     rescue SystemCallError
       nil

data/lib/claude_inbox/rate_limits.rb

@@ -18,9 +18,7 @@ module ClaudeInbox
     LABELS = {"five_hour" => "session", "seven_day" => "week"}.freeze
 
     # `resets_at` is when the window rolls over, or nil if the file omits it.
-    Window = Data.define(:label, :percent, :resets_at) do
-      def initialize(label:, percent:, resets_at: nil) = super
-    end
+    Window = Data.define(:label, :percent, :resets_at)
 
     def initialize(path: DEFAULT_PATH)
       @path = path
@@ -32,7 +30,7 @@ module ClaudeInbox
     # time, or nil.
     # Parses only when the file has changed, since render asks several times
     # a second.
-    def windows(now = Time.now)
+    def windows(now)
       mtime = File.mtime(@path)
       return nil if now - mtime > STALE_AFTER
       @data = parse if mtime != @mtime

data/lib/claude_inbox/reaper.rb

@@ -20,15 +20,13 @@ module ClaudeInbox
     RETRY_AFTER = 24 * 3600
     DEFAULT_LOG = File.join(Dir.home, ".config", "claude-inbox", "reaped.log")
 
-    def initialize(client, store, log_path: DEFAULT_LOG, enabled: self.class.enabled?)
+    def initialize(client, store, log_path: DEFAULT_LOG, enabled: true)
       @client = client
       @store = store
       @log_path = log_path
       @enabled = enabled
     end
 
-    def self.enabled? = ENV["CLAUDE_INBOX_NO_REAP"].to_s.empty?
-
     # For --fixture runs and tests: selects nothing, deletes nothing, and
     # needs neither a client nor a store to do it.
     def self.disabled = new(nil, nil, enabled: false)

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)
@@ -104,7 +107,7 @@ module ClaudeInbox
         end
       end
 
-      def self.write(io, status, headers = {}, body = "")
+      def self.write(io, status, headers, body)
         body = body.b
         head = ["HTTP/1.1 #{status} #{REASONS.fetch(status)}"]
         HEADERS.merge(headers, "Content-Length" => body.bytesize.to_s).each { |name, value| head << "#{name}: #{value}" }

data/lib/claude_inbox/remote/listener.rb

@@ -17,7 +17,7 @@ module ClaudeInbox
     # connection limits, the static files and the Pairing token, in front of
     # Start. Like the Poller it reaches App only through the queue, and it
     # never writes to the terminal: every failure becomes a response or a
-    # notice.
+    # notice. It is App's only way into Remote.
     class Listener
       DEFAULT_PORT = 7433
       DEFAULT_MODES = %w[default auto plan].freeze
@@ -58,17 +58,13 @@ module ClaudeInbox
       # lock, as `held_by`) or :failed (for good, as `error` says). `urls` and
       # `firewall` are nil until `refresh`.
       Snapshot = Data.define(:state, :port, :lan, :urls, :firewall, :allowed_modes, :recent, :held_by, :fixture, :error) do
-        def initialize(error: nil, **) = super
-
         # Over a VPN only an address reaches the Mac: multicast DNS, which
         # the .local name needs, stays on the LAN.
         def pairing_url = (lan && urls&.[](1)) || urls&.first
       end
 
       # `count` is how many times `via` got `result`, the last at `at`.
-      Outcome = Data.define(:at, :via, :result, :count) do
-        def initialize(at:, via:, result:, count: 1) = super
-      end
+      Outcome = Data.define(:at, :via, :result, :count)
 
       # App's `listen:` from the flags, else the environment; nil when neither
       # asks for it. --listen-lan wins over --listen, whichever came last.
@@ -109,7 +105,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 +115,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

@@ -26,15 +26,14 @@ module ClaudeInbox
       BODY_TIMEOUT = 120
       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)
+      def initialize(client:, store:, queue:, allowed_modes:, fixture:, images_dir: Images::DEFAULT_DIR,
+        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
@@ -63,13 +62,7 @@ module ClaudeInbox
         }
       end
 
-      # Where sessions ran lately, newest first, then every directory whose
-      # trust dialog was accepted: the likely choices first. Only an order;
-      # the CLI still decides where a session may start.
-      def dir_paths
-        recent = @store.sessions.sort_by { |s| -s.started_at.to_i }.filter_map { |s| s.cwd && SessionRequest.strip_worktree(s.cwd) }
-        (recent + @trust.call).uniq.select { |dir| File.directory?(dir) }
-      end
+      def dir_paths = SessionRequest.directories(@store.sessions, @trust.call)
 
       # Checked cheapest first, and nothing is written to disk until every
       # check has passed. A retry with the same Idempotency-Key gets the
@@ -192,7 +185,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

@@ -11,12 +11,6 @@ module ClaudeInbox
   # `width` columns wide) plus a parallel Array of selectable items.
   # Pure: no terminal, no IO, no clock beyond the `now` it is handed.
   class Renderer
-    Item = Struct.new(:kind, :row, :section) do
-      def selection = (kind == :fold_toggle) ? Store::Selection.fold(section) : Store::Selection.row(row.key)
-
-      def key = selection.key
-    end
-
     Frame = Struct.new(:lines, :items, :top, :list_width)
 
     CHROME_ROWS = 2 # header + footer
@@ -81,14 +75,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)
@@ -175,7 +169,7 @@ module ClaudeInbox
       end
     end
 
-    def header_chips(sections, compact:, listening: nil)
+    def header_chips(sections, compact:, listening:)
       pinned = sections.pinned.size
       needing = sections.needs_you.size
       working = sections.active.count { |r| r.session.effective_state == "working" && !r.session.waiting_on_work? }
@@ -214,7 +208,7 @@ module ClaudeInbox
 
     def footer(width, view)
       text =
-        if view.filter_editing then " " + @theme.cyan_bold("/") + line(view.filter, width - 2)
+        if view.filter_editing then " " + @theme.cyan_bold("/") + view.filter.row(width - 2, cursor: caret)
         elsif view.filter then " " + @theme.cyan_bold("/") + view.filter.to_s + @p.dim("  esc clears")
         else " " + footer_keys(view).map { |k, d| @theme.cyan_bold(k) + " " + @p.dim(d) }.join("  ")
         end
@@ -226,8 +220,6 @@ module ClaudeInbox
       KEYS.flat_map { |key| (key[0] == "n") ? [key, ["N", "pair"]] : [key] }
     end
 
-    def line(buffer, width) = buffer.row(width, cursor: caret)
-
     def section_title(name, count, width)
       title = " #{SECTION_TITLES[name]} "
       count_s = " #{count} "
@@ -243,7 +235,7 @@ module ClaudeInbox
 
     # ----- body ---------------------------------------------------------------
 
-    def body_lines(sections, width, view, now)
+    def body_lines(sections, width, view)
       lines = []
       items = []
       if sections.all.empty?
@@ -256,13 +248,13 @@ module ClaudeInbox
         items << nil << nil
         if Store.folded?(name, view.expanded)
           lines << fold_toggle_line(name, rows.size, selected, width)
-          items << Item.new(:fold_toggle, nil, name)
+          items << Store::Selection.fold(name)
           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)
+            items << ((i.zero? && row.selectable?) ? Store::Selection.row(row.key) : nil)
           end
         end
       end

data/lib/claude_inbox/session_request.rb

@@ -80,6 +80,16 @@ module ClaudeInbox
     # writing over the same files. Fall back to the repo it was cut from.
     def self.strip_worktree(cwd) = cwd.to_s.sub(%r{/\.claude/worktrees/[^/]+(?:/.*)?\z}, "")
 
+    # Where sessions ran lately, newest first, then every directory whose
+    # trust dialog was accepted: the likely choices first. Only an order;
+    # the CLI still decides where a session may start. Every worktree gets
+    # trusted on its own, so each folds into its repo rather than crowding
+    # the list.
+    def self.directories(sessions, trusted)
+      recent = sessions.sort_by { |s| -s.started_at.to_i }.filter_map(&:cwd)
+      (recent + trusted).map { |dir| strip_worktree(dir) }.uniq.select { |dir| File.directory?(dir) }
+    end
+
     # The daemon's summary line can echo the prompt to the terminal, so no
     # control character but tab and newline gets that far. A CRLF, the
     # newline an HTTP client may send, is taken as a newline.

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

@@ -13,7 +13,7 @@ module ClaudeInbox
   #
   # Pure: filesystem in, plain values out. Nothing here runs `claude`.
   module SlashCommands
-    Command = Struct.new(:name, :description, :source) do
+    Command = Struct.new(:name, :description) do
       def to_s = "/#{name}"
     end
 
@@ -26,8 +26,8 @@ module ClaudeInbox
     def list(cwd:, home: Dir.home)
       found = {}
       add = ->(cmd) { found[cmd.name] ||= cmd }
-      from_dir(File.join(cwd, ".claude"), "project").each(&add)
-      from_dir(File.join(home, ".claude"), "user").each(&add)
+      from_dir(File.join(cwd, ".claude")).each(&add)
+      from_dir(File.join(home, ".claude")).each(&add)
       plugins(home).each(&add)
       synced(home).each(&add)
       found.values.sort_by(&:name)
@@ -39,25 +39,25 @@ module ClaudeInbox
       starts + rest.select { |c| c.name.downcase.include?(q) }
     end
 
-    def from_dir(dir, source, prefix: nil)
-      skills(File.join(dir, "skills"), source, prefix:) +
-        commands(File.join(dir, "commands"), source, prefix:)
+    def from_dir(dir, prefix: nil)
+      skills(File.join(dir, "skills"), prefix:) +
+        commands(File.join(dir, "commands"), prefix:)
     end
 
-    def skills(dir, source, prefix: nil)
+    def skills(dir, prefix: nil)
       Dir.glob(File.join(dir, "*", "SKILL.md")).sort.filter_map do |path|
         meta = frontmatter(path)
         next if meta["user-invocable"] == "false"
         name = File.basename(File.dirname(path))
-        Command.new(qualify(prefix, name), meta["description"].to_s, source)
+        Command.new(qualify(prefix, name), meta["description"].to_s)
       end
     end
 
     # A command file's name is its own; a subdirectory only groups them.
-    def commands(dir, source, prefix: nil)
+    def commands(dir, prefix: nil)
       Dir.glob(File.join(dir, "**", "*.md")).sort.map do |path|
         name = File.basename(path, ".md")
-        Command.new(qualify(prefix, name), frontmatter(path)["description"].to_s, source)
+        Command.new(qualify(prefix, name), frontmatter(path)["description"].to_s)
       end
     end
 
@@ -71,7 +71,7 @@ module ClaudeInbox
       (installed["plugins"] || {}).flat_map do |key, entries|
         plugin = key.split("@").first
         Array(entries).filter_map { |e| e["installPath"] if e.is_a?(Hash) }.uniq.flat_map do |root|
-          from_dir(root, "plugin", prefix: plugin)
+          from_dir(root, prefix: plugin)
         end
       end
     end
@@ -80,7 +80,7 @@ module ClaudeInbox
     # ~/.claude/skills/synced and answer to the anthropic-skills prefix.
     def synced(home)
       Dir.glob(File.join(home, ".claude", "skills", "synced", "*", "")).flat_map do |bucket|
-        skills(bucket, "synced", prefix: SYNCED_PLUGIN)
+        skills(bucket, prefix: SYNCED_PLUGIN)
       end
     end
 
@@ -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