lux-hammer 0.3.28 → 0.3.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48fd3473ba922f93fa0ebcc897d0bf6a88ec78283ed4436281d938a1297e53ac
-  data.tar.gz: 30eef033e89155cd82b362563e5f4dea0716551f56d686ae5c1fde16fc23170c
+  metadata.gz: 2ca175d7445c386d0c8bd3be6834b057e6b958ee3d0de48d72e49a53ef4da776
+  data.tar.gz: 3303a15ee74702d81ebfba70d15366870bfb8dccc2d5b0fc8c5304e2fe28ef0e
 SHA512:
-  metadata.gz: 7e3961d9aa6c6d89081ec6e1ee111346fab1944c8152644c7e22b300815bea3152606459c6d90e88592c8933021cc7c8ba75b262f8c5aebc4105b05816c0b9cb
-  data.tar.gz: 50fd5ecc020ecb0d31ad7f79d7d7dc5ae313e6646c30cdc0758b07bfbad1bfe145f50301215853b168cd3d79ccd5d66f0372551f405984ac87b0d026f13d047f
+  metadata.gz: d925611cf831aa0e6c4198d4761bdcb04b7454afab82a8cc12100130e23dc63139f3bad8fbf0473cd67f7bf71ea46ef3ceeb91e266f6bddba51f4097469231dc
+  data.tar.gz: a489e910f4027422474b1741a0ff45e4e5729009af2d5c6ba7fbf79a7f11661e547b9947058c6b5c237e41fbecfc5baa9a2a2686158a95460a0c2be7ba4bf329

data/.version

@@ -1 +1 @@
-0.3.28
+0.3.30

data/lib/lux-hammer.rb

@@ -1281,10 +1281,12 @@ class Hammer
   # built-ins (so the script's `--help` shows only what it defines).
   # `program_name` is the script's basename so help reads "myscript foo"
   # rather than "hammer foo" - works even when invoked via a symlink in
-  # PATH, since argv[0] is the path the user typed.
+  # PATH, since argv[0] is the path the user typed. `.rb` is stripped so
+  # a recipe exec'd as `recipes/llm.rb` (typical `~/bin/llm` stub) still
+  # banners as `llm`, matching `Hammer.recipe(:llm)`.
   def self.run_shebang(path, argv)
     klass = Class.new(Hammer)
-    klass.instance_variable_set(:@program_name, File.basename(path))
+    klass.instance_variable_set(:@program_name, File.basename(path, '.rb'))
     Builder.new(klass).evaluate(File.read(path), path)
     klass.start(argv)
   end

data/recipes/git-helper.rb

@@ -450,6 +450,26 @@ task :pr do
   proc { open_in_browser(remote_pr_url) }
 end
 
+task :prs do
+  desc 'list open PRs: id, author, short title, url (others first, then mine)'
+  proc do |_|
+    require 'json'
+    out = `GH_PAGER=cat gh pr list --state open --limit 100 --json number,title,url,author`
+    error 'gh pr list failed' unless $?.success?
+    prs = JSON.parse(out)
+    next say('No open PRs', :yellow) if prs.empty?
+    me = `GH_PAGER=cat gh api user --jq .login`.chomp
+    mine, others = prs.partition { |pr| pr.dig('author', 'login') == me }
+    author_width = prs.map { |pr| pr.dig('author', 'login').to_s.length }.max
+    (others + mine).each do |pr|
+      title  = pr['title'].length > 50 ? "#{pr['title'][0, 49]}…" : pr['title']
+      author = pr.dig('author', 'login').to_s.ljust(author_width)
+      author = author.color(mine.include?(pr) ? :green : :blue)
+      puts "#{"##{pr['number']}".ljust(7).color(:yellow)} #{author}  #{title.ljust(50)}  #{pr['url']}"
+    end
+  end
+end
+
 # ---- tags / users / stats --------------------------------------------
 
 task :tag do

data/recipes/lib/llm/launch.rb

@@ -9,17 +9,24 @@ require 'pathname'
 module LlmLaunch
   Launch = Struct.new(:argv, :env, :files)
 
+  # The one registry of agent CLIs. :continue / :full / :agents drive a launch;
+  # :update / :version / :models drive `llm wrap:run --update` (LlmUpdate).
   # :agents gets the combined AGENTS.md text and the file paths, and answers
   # with the argv to add and/or env to set - opencode has no flag for
   # instructions, only inline config, and that one takes paths.
+  # :models is nil where the CLI has no listing command - skip, not "none".
   TOOLS ||= {
     'claude'   => { continue: %w[-c],            full: %w[--dangerously-skip-permissions],
+                    update: %w[claude update],   version: %w[claude --version],   models: nil,
                     agents: ->(text, _files) { { args: ['--append-system-prompt', text] } } },
     'codex'    => { continue: %w[resume --last], full: %w[--dangerously-bypass-approvals-and-sandbox],
+                    update: %w[codex update],    version: %w[codex --version],    models: nil,
                     agents: ->(text, _files) { { args: ['-c', "developer_instructions=#{text}"] } } },
     'grok'     => { continue: %w[-c],            full: %w[--always-approve],
+                    update: %w[grok update],     version: %w[grok version],       models: %w[grok models],
                     agents: ->(text, _files) { { args: ['--rules', text] } } },
     'opencode' => { continue: %w[-c],            full: %w[--auto],
+                    update: %w[opencode upgrade], version: %w[opencode --version], models: %w[opencode models],
                     agents: ->(_text, files) { { env: { 'OPENCODE_CONFIG_CONTENT' => { instructions: files }.to_json } } } },
   }.freeze
 

data/recipes/lib/llm/update.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+require_relative 'launch'
+
+# Backs `llm wrap:run --update` (`ai --update`): runs each agent CLI's own
+# updater and reports old -> new, then re-reads the model lists and shows what
+# appeared or disappeared since the last run. None of these tools download
+# model weights - the models are API-side, so the list is the thing that moves.
+module LlmUpdate
+  extend Hammer::Shell
+
+  CACHE_PATH ||= File.expand_path('~/.cache/llm/models.json')
+  WIDTH      ||= LlmLaunch::TOOLS.keys.map(&:size).max
+
+  # How each CLI prints its list: grok bullets it under a preamble ("You are
+  # not authenticated." when logged out) and marks the default, opencode prints
+  # one bare provider/model per line.
+  MODEL_RE ||= {
+    'grok'     => /\A\s*[*-]\s+(\S+)/,
+    'opencode' => %r{\A(\S+/\S+)\z},
+  }.freeze
+
+  module_function
+
+  # Returns the exit status - non-zero if any updater failed.
+  def run(tools)
+    rows = tools.map { |tool| update_one(tool) }
+    say ''
+    rows.each { |row| report(row) }
+    report_models(rows.select { |row| row[:installed] }.map { |row| row[:tool] })
+    rows.any? { |row| row[:failed] } ? 1 : 0
+  end
+
+  def update_one(tool)
+    return { tool: tool, installed: false } unless command?(tool)
+
+    argv = LlmLaunch::TOOLS.fetch(tool)[:update]
+    before = version(tool)
+    say.gray "$ #{argv.join(' ')}"
+    ok = system(*argv)
+    { tool: tool, installed: true, before: before, after: version(tool), failed: !ok }
+  end
+
+  def report(row)
+    name = row[:tool].ljust(WIDTH)
+    return say.gray("* #{name}  not installed") unless row[:installed]
+    return say.red("* #{name}  update failed") if row[:failed]
+
+    before, after = row.values_at(:before, :after)
+    if before && after && before != after
+      say.green "* #{name}  #{before} -> #{after}"
+    elsif after
+      say "* #{name}  #{after} (latest)"
+    else
+      say "* #{name}  #{before || 'unknown version'}"
+    end
+  end
+
+  def report_models(tools)
+    tools = tools.select { |tool| LlmLaunch::TOOLS.fetch(tool)[:models] }
+    return if tools.empty?
+
+    cache = cache_read
+    say ''
+    say 'models'
+    tools.each { |tool| cache[tool] = report_model_list(tool, cache[tool]) }
+    cache_write(cache)
+  end
+
+  # Prints one tool's list against the previously cached one, and answers with
+  # the fresh list so the caller can write it back.
+  def report_model_list(tool, old)
+    list = models(tool)
+    name = tool.ljust(WIDTH)
+    if list.empty?
+      say.gray "  #{name}  no models listed"
+      return old || []
+    end
+
+    say "  #{name}  #{list.size} models"
+    unless old
+      say.gray '    (first run)'
+      return list
+    end
+
+    added, removed = diff(old, list)
+    say.gray('    unchanged') if added.empty? && removed.empty?
+    added.each   { |model| say.green "    + #{model}" }
+    removed.each { |model| say.gray "    - #{model}" }
+    list
+  end
+
+  def version(tool)
+    parse_version(capture(LlmLaunch::TOOLS.fetch(tool)[:version]))
+  end
+
+  def models(tool)
+    parse_models(tool, capture(LlmLaunch::TOOLS.fetch(tool)[:models]))
+  end
+
+  # `2.1.268 (Claude Code)`, `codex-cli 0.154.0`, `grok 1.0.25 (f7e67d6) [stable]`, `1.18.30`
+  def parse_version(out)
+    out.to_s.lines.first.to_s[/\d+\.\d+(?:\.\d+)*/]
+  end
+
+  def parse_models(tool, out)
+    re = MODEL_RE[tool]
+    return [] unless re
+    out.to_s.lines.filter_map { |line| line.rstrip[re, 1] }.uniq.sort
+  end
+
+  def diff(old, new)
+    [new - old, old - new]
+  end
+
+  def cache_read
+    JSON.parse(File.read(CACHE_PATH))
+  rescue StandardError
+    {}
+  end
+
+  def cache_write(data)
+    FileUtils.mkdir_p(File.dirname(CACHE_PATH))
+    tmp = "#{CACHE_PATH}.#{Process.pid}.tmp"
+    File.write(tmp, JSON.pretty_generate(data))
+    File.rename(tmp, CACHE_PATH)
+  end
+
+  def capture(argv)
+    IO.popen(argv, err: %i[child out], &:read).to_s
+  rescue StandardError
+    ''
+  end
+
+  def command?(name)
+    ENV.fetch('PATH', '').split(File::PATH_SEPARATOR).any? { |dir| File.executable?(File.join(dir, name)) }
+  end
+end

data/recipes/lib/llm/usage.rb

@@ -64,7 +64,7 @@ module LlmUsage
       # and caching would freeze the staleness note. Only the API call caches.
       data, note = fetch_claude_usage(period: label, cache: cache, now: now)
       notes << note unless note.nil? || note.empty?
-      rows.concat(parse_claude(data, now: now)) if data
+      rows.concat(parse_claude(data, now: now, period: label)) if data
     end
 
     if wanted.include?(:codex)
@@ -294,7 +294,7 @@ module LlmUsage
     "#{mins}m"
   end
 
-  def parse_claude(data, now: Time.now)
+  def parse_claude(data, now: Time.now, period: nil)
     return [] unless data.is_a?(Hash)
 
     five = data['five_hour']
@@ -329,13 +329,13 @@ module LlmUsage
           month_reset: '-'
         )
       end
-      return rows
+      return rows + claude_scoped_rows(data['limits'], rows, now: now, period: period)
     end
 
     week = data['seven_day']
     return [] unless five.is_a?(Hash) || week.is_a?(Hash)
 
-    [
+    rows = [
       UsageRow.new(
         name: 'Claude',
         session_pct: format_pct(session_pct),
@@ -346,6 +346,36 @@ module LlmUsage
         month_reset: month[:reset]
       )
     ]
+    rows + claude_scoped_rows(data['limits'], rows, now: now, period: period)
+  end
+
+  # Per-model weekly buckets live in `limits` as kind weekly_scoped - Fable has
+  # one, and seven_day_opus/_sonnet read null on the accounts that do. Named off
+  # the API's own display_name, so a model added later needs nothing here; a
+  # scope already carrying its own seven_day_* row is skipped rather than
+  # doubled. A weekly bucket has nothing to say in the month view, where these
+  # would be a row of dashes.
+  def claude_scoped_rows(limits, rows, now: Time.now, period: nil)
+    return [] if period_label(period) == 'month'
+
+    taken = rows.map(&:name)
+
+    Array(limits).filter_map do |limit|
+      next unless limit.is_a?(Hash) && limit['kind'] == 'weekly_scoped'
+
+      name = limit.dig('scope', 'model', 'display_name')
+      next if name.nil? || name.empty? || taken.include?(name)
+
+      UsageRow.new(
+        name: name,
+        session_pct: '-',
+        session_reset: '-',
+        week_pct: format_pct(limit['percent']),
+        week_reset: format_reset_short(limit['resets_at'], now: now),
+        month_pct: '-',
+        month_reset: '-'
+      )
+    end
   end
 
   def parse_codex(data, now: Time.now)
@@ -403,7 +433,7 @@ module LlmUsage
     return fetch_cached(:claude, cache) { fetch_claude_oauth_usage } if period == 'month'
 
     data, note = fetch_claude_snapshot(now: now, path: path)
-    return [data, note] if data
+    return [merge_scoped_limits(data, cache: cache), note] if data
 
     api_data, api_note = fetch_cached(:claude, cache) { fetch_claude_oauth_usage }
     return [api_data, api_note] if api_data
@@ -411,6 +441,18 @@ module LlmUsage
     [nil, [note, api_note].compact.join('; ')]
   end
 
+  # The statusline snapshot carries no per-model windows - Claude Code's
+  # `rate_limits` input is five_hour/seven_day and nothing else - so borrow
+  # `limits` from the API payload. Cached, so this is one call per CACHE_TTL,
+  # and silent when it fails: the snapshot's own numbers are still good.
+  def merge_scoped_limits(data, cache: true)
+    api, = fetch_cached(:claude, cache) { fetch_claude_oauth_usage }
+    limits = api['limits'] if api.is_a?(Hash)
+    return data unless limits
+
+    data.merge('limits' => limits)
+  end
+
   def fetch_claude_snapshot(now: Time.now, path: CLAUDE_LIMITS_PATH)
     snapshot = read_json(path)
     return [nil, 'claude: no local snapshot (statusline writer not installed)'] unless snapshot.is_a?(Hash)
@@ -685,11 +727,12 @@ module LlmUsage
       end
     end
 
+    # A failure is cached too, or an unreachable endpoint costs its timeout on
+    # every run - and the snapshot path that now consults the API is the one
+    # that used to be instant and offline.
     data, note = yield
-    if data
-      FileUtils.mkdir_p(CACHE_DIR)
-      File.write(path, JSON.generate('fetched_at' => Time.now.iso8601, 'data' => data, 'note' => note))
-    end
+    FileUtils.mkdir_p(CACHE_DIR)
+    File.write(path, JSON.generate('fetched_at' => Time.now.iso8601, 'data' => data, 'note' => note))
     [data, note]
   end
 

data/recipes/lib/llm/wrap.rb

@@ -673,10 +673,12 @@ module LlmWrap
   #   * a sequence, leaving the introducer stranded and its tail printed as
   #     text - the literal "[22m" on screen
   #   * a UTF-8 character, which comes out as a replacement glyph
-  #   * a DECSC the child opened and has not closed yet. The terminal has one
-  #     save slot; we take it, and the child's own ESC8 then puts its cursor on
-  #     our bar and it draws the rest of the frame over the top. Claude Code
-  #     wraps every repaint in ESC7 ... ESC8, so this one is not theoretical.
+  #   * a cursor save the child opened and has not restored yet, in either the
+  #     DECSC (ESC7/ESC8) or SCO (CSI s / CSI u) form. The terminal has one save
+  #     slot; we take it, and the child's own restore then puts its cursor on our
+  #     bar and it draws the rest of the frame over the top. Claude Code brackets
+  #     every repaint in ESC7 ... ESC8 and OpenCode uses CSI s ... CSI u, so this
+  #     one is not theoretical.
   #
   # This is only ever asked about the *end* of what we have written so far, so
   # there is no need to understand the sequences - just to know where they stop.
@@ -774,11 +776,20 @@ module LlmWrap
     end
 
     def csi(byte)
+      first = @len.zero?
       @len += 1
       return @state = :esc if byte == ESC       # aborted, a new one starting
       return @state = :text if @len > MAX_CSI
 
-      @state = :text if byte >= 0x40 && byte <= 0x7e
+      if byte >= 0x40 && byte <= 0x7e
+        # SCO save/restore (CSI s / CSI u) share the single save slot with
+        # DECSC/DECRC on the emulators we run against, and OpenCode repaints
+        # through this pair - a paint between them takes the slot and its
+        # restore lands the rest of the frame on our bar.
+        @saved += 1 if first && byte == 0x73
+        @saved -= 1 if first && byte == 0x75 && @saved.positive?
+        @state = :text
+      end
     end
 
     # String payloads run to BEL or ST (ESC \).

data/recipes/llm.rb

@@ -9,7 +9,7 @@ desc <<~TXT
     browser  drive a local Chrome with Stagehand, thinking through claude / codex / ollama
     memory   persistent memory store (backs the Claude Code memory plugin)
     plan     apply a /plan bundle - sha1 checked, drift aware
-    prompt   token-prefix prompt expander (UserPromptSubmit hook + CLI)
+    prompt   ::token prompt expander (UserPromptSubmit hook + CLI)
 
   Commands:
     usage    subscription limits and per-model token usage
@@ -45,8 +45,10 @@ task :usage do
     `~/.grok/logs/unified.jsonl` for the period end; tokens still sum
     inference_done events in that log. Claude 5h/week windows come from the
     statusline snapshot at `~/.cache/llm/claude-limits.json`, falling back to
-    the OAuth usage API. `month` shows Claude extra-usage credits (API only,
-    and only when you've enabled them).
+    the OAuth usage API. Per-model weekly windows (Fable) get their own row and
+    come from that API either way - the snapshot doesn't carry them. `month`
+    shows Claude extra-usage credits (API only, and only when you've enabled
+    them).
   D
   example 'usage'
   example 'usage month'
@@ -205,6 +207,11 @@ namespace :wrap do
                                               approvals-and-sandbox, --always-approve, --auto
         -b  bare - no AGENTS.md injection     skips the default below
 
+      --update runs each CLI's own updater (claude/codex/grok update, opencode upgrade),
+      reports old -> new, then re-reads the model lists and shows what appeared or
+      disappeared since the last run. A TOOL prefix scopes it to that one tool; no prefix
+      updates all four.
+
       By default every AGENTS.md from ~ down to cwd is handed to the tool: claude
       --append-system-prompt, codex -c developer_instructions, grok --rules, opencode
       inline config. codex, grok and opencode read AGENTS.md from the git root down by
@@ -215,10 +222,12 @@ namespace :wrap do
     example 'wrap:run g -cf'
     example 'wrap:run cod -cb'
     example 'wrap:run c -- --model opus'
+    example 'wrap:run --update'
 
     opt :continue, type: :boolean, desc: 'continue the last session in this folder'
     opt :full,     type: :boolean, desc: 'full permissions, no approval prompts'
     opt :bare,     type: :boolean, desc: 'bare agent - do not inject AGENTS.md'
+    opt :update,   type: :boolean, desc: 'update the agent CLIs, then show model changes'
 
     proc do |opts|
       require File.join(_llm_root, 'lib/llm/wrap')
@@ -230,6 +239,11 @@ namespace :wrap do
              error("unknown tool #{prefix.inspect} - one of #{LlmLaunch::TOOLS.keys.join(', ')}")
       extra = prefix ? args.drop(1) : args
 
+      if opts[:update]
+        require File.join(_llm_root, 'lib/llm/update')
+        exit LlmUpdate.run(prefix ? [tool] : LlmLaunch::TOOLS.keys)
+      end
+
       launch = LlmLaunch.build(tool, extra, continue: opts[:continue], full: opts[:full], bare: opts[:bare])
       ENV.update(launch.env)
       say.gray "agents: #{launch.files.map { |f| f.to_s.sub(Dir.home, '~') }.join(', ')}" if launch.files.any?
@@ -484,7 +498,7 @@ end
 
 namespace :prompt do
   TOKEN_PATTERN        ||= /[a-z0-9_-]+/.freeze
-  TOKEN_LINE_RE        ||= /\A(?:\s*:[a-z0-9_-]+)+\s*\z/.freeze
+  TOKEN_LINE_RE        ||= /\A(?:\s*::[a-z0-9_-]+)+\s*\z/.freeze
   HOOK_EVENT           ||= 'UserPromptSubmit'
   VERBATIM_INSTRUCTION ||= "INSTRUCTION TO ASSISTANT: Do not answer the user's prompt. Print the message below verbatim to the user, preserving every line exactly as written. Do not summarize, truncate, or paraphrase."
   QUESTION_RULE        ||= <<~RULE.strip
@@ -506,8 +520,8 @@ namespace :prompt do
   def tokens_in(input)
     out = []
     scanner = input.to_s.strip
-    while (m = scanner.match(/\A(?::(?<pre>#{TOKEN_PATTERN})|(?<post>#{TOKEN_PATTERN}):)(?=\s|$)/))
-      out << (m[:pre] || m[:post])
+    while (m = scanner.match(/\A::(#{TOKEN_PATTERN})(?=\s|$)/))
+      out << m[1]
       scanner = scanner[m[0].length..].to_s.lstrip
     end
     out.uniq
@@ -529,7 +543,7 @@ namespace :prompt do
     ordered = folders.sort_by { |label, _| label == 'global' ? 0 : 1 }
     ordered.map do |label, folder|
       toks = Dir.glob(File.join(folder, '*.md')).map { |p| File.basename(p, '.md') }.sort
-      items = toks.empty? ? '(none)' : toks.map { |t| ":#{t}" }.join(', ')
+      items = toks.empty? ? '(none)' : toks.map { |t| "::#{t}" }.join(', ')
       "Available #{label} in #{display_path(folder)} -> #{items}"
     end.join("\n")
   end
@@ -547,7 +561,7 @@ namespace :prompt do
           name = File.basename(path, '.md')
           dscr = first_line_description(path)
           dscr = '(no description)' if dscr.empty?
-          "  :#{name.ljust(width)}  #{dscr}"
+          "  ::#{name.ljust(width)}  #{dscr}"
         end
         "#{header}\n#{entries.join("\n")}"
       end
@@ -617,7 +631,7 @@ namespace :prompt do
       end
 
       break unless stripped =~ TOKEN_LINE_RE
-      prefix_tokens.concat(stripped.scan(/:(#{TOKEN_PATTERN})/).flatten)
+      prefix_tokens.concat(stripped.scan(/::(#{TOKEN_PATTERN})/).flatten)
       remaining = rest.to_s
     end
 
@@ -638,9 +652,9 @@ namespace :prompt do
   end
 
   def load_command_content(token, seen)
-    error "circular include of :#{token}" if seen.include?(token)
+    error "circular include of ::#{token}" if seen.include?(token)
     path = find_command_path(token)
-    error %(custom token ":#{token}" not found.\n\n#{grouped_listing}) unless path
+    error %(custom token "::#{token}" not found.\n\n#{grouped_listing}) unless path
 
     child_seen = seen + [token]
     content = File.read(path)
@@ -669,7 +683,7 @@ namespace :prompt do
     seen = Set.new
     loaded = toks.map do |token|
       path = find_command_path(token)
-      error %(custom token ":#{token}" not found.\n\n#{grouped_listing}) unless path
+      error %(custom token "::#{token}" not found.\n\n#{grouped_listing}) unless path
       [token, Pathname.new(path).cleanpath.to_s, load_command_content(token, seen)]
     end
 
@@ -719,12 +733,11 @@ namespace :prompt do
 
   task :expand do
     desc 'Expand prompt token(s) and print the resulting context'
-    example 'prompt:expand :foo :bar'
-    example 'prompt:expand foo:'
+    example 'prompt:expand ::foo ::bar'
 
     proc do |opts|
       input = opts[:args].join(' ')
-      error 'usage: llm prompt:expand :token [:token ...]' if input.empty?
+      error 'usage: llm prompt:expand ::token [::token ...]' if input.empty?
       out = load_context(input)
       say out unless out.empty?
     end
@@ -733,16 +746,17 @@ namespace :prompt do
   task :hook do
     desc <<~D
       UserPromptSubmit hook entry. Reads {"prompt": ...} JSON on stdin,
-      expands any token prefix, and emits hookSpecificOutput JSON on stdout.
+      expands any ::token prefix, and emits hookSpecificOutput JSON on stdout.
 
       Pair with HAMMER_QUIET=1 in the hook command so the runtime banner
       doesn't pollute stdout.
     D
     opt :claude, type: :boolean, default: false, desc: 'Claude Code hook mode'
     opt :codex,  type: :boolean, default: false, desc: 'Codex hook mode'
+    opt :grok,   type: :boolean, default: false, desc: 'Grok CLI hook mode'
 
     proc do |opts|
-      error '--claude or --codex required' unless opts[:claude] || opts[:codex]
+      error '--claude, --codex or --grok required' unless opts[:claude] || opts[:codex] || opts[:grok]
 
       raw = opts[:stdin].to_s
       prompt = begin

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lux-hammer
 version: !ruby/object:Gem::Version
-  version: 0.3.28
+  version: 0.3.30
 platform: ruby
 authors:
 - Dino Reic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-09 00:00:00.000000000 Z
+date: 2026-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -58,6 +58,7 @@ files:
 - "./recipes/lib/llm/browser.rb"
 - "./recipes/lib/llm/launch.rb"
 - "./recipes/lib/llm/plan.rb"
+- "./recipes/lib/llm/update.rb"
 - "./recipes/lib/llm/usage.rb"
 - "./recipes/lib/llm/wrap.rb"
 - "./recipes/llm.rb"