openclacky 1.5.11 → 1.5.13

data/lib/clacky/server/web_ui_controller.rb

@@ -96,7 +96,7 @@ module Clacky
         forward_to_subscribers { |sub| sub.show_user_message(content) if sub.respond_to?(:show_user_message) }
       end
 
-      def show_assistant_message(content, files:, interim: false)
+      def show_assistant_message(content, files:, interim: false, created_at: nil)
         return if (content.nil? || content.to_s.strip.empty?) && files.empty?
 
         # Rewrite local image paths (file:// and bare absolute) to /api/local-image
@@ -105,7 +105,7 @@ module Clacky
         # Channel subscribers receive the original content so they can deliver
         # local images as native attachments via send_file().
         web_content = Clacky::Utils::FileProcessor.rewrite_local_image_urls(content.to_s)
-        emit("assistant_message", content: web_content, files: files)
+        emit("assistant_message", content: web_content, files: files, created_at: created_at)
         forward_to_subscribers { |sub| sub.show_assistant_message(content, files: files, interim: interim) }
       end
 
@@ -128,7 +128,8 @@ module Clacky
                context: context,
                options: first[:options] || [],
                questions: questions)
-          # Don't forward to IM subscribers — they get the formatted text version already
+          # IM subscribers render the same questions as plain text — they have no card.
+          forward_to_subscribers { |sub| sub.show_tool_call(name, args_data) }
           return
         end
 
@@ -189,8 +190,9 @@ module Clacky
         # Token usage is internal detail — intentionally not forwarded
       end
 
-      def show_complete(iterations:, cost:, duration: nil, cache_stats: nil, awaiting_user_feedback: false, cost_source: nil)
+      def show_complete(iterations:, cost:, duration: nil, cache_stats: nil, awaiting_user_feedback: false, cost_source: nil, task_id: nil)
         data = { iterations: iterations, cost: cost }
+        data[:task_id]                = task_id             if task_id
         data[:duration]               = duration            if duration
         data[:cache_stats]            = cache_stats         if cache_stats
         data[:awaiting_user_feedback] = awaiting_user_feedback if awaiting_user_feedback
@@ -199,7 +201,7 @@ module Clacky
         forward_to_subscribers do |sub|
           sub.show_complete(iterations: iterations, cost: cost, duration: duration,
                             cache_stats: cache_stats, awaiting_user_feedback: awaiting_user_feedback,
-                            cost_source: cost_source)
+                            cost_source: cost_source, task_id: task_id)
         end
       end
 

data/lib/clacky/session_manager.rb

@@ -34,18 +34,32 @@ module Clacky
 
       @last_saved_path = filepath
 
-      # Keep only the most recent 200 sessions (best-effort, never block save)
-      begin
-        cleanup_by_count(keep: 200, grouped_keep: 200)
-        cleanup_trash(days: 8)
-        cleanup_file_trash(days: 8)
-      rescue StandardError
-        # Cleanup is non-critical; swallow file errors but never AgentInterrupted
-      end
+      run_cleanup_async
 
       filepath
     end
 
+    # Run the best-effort maintenance chores off the save path. File-trash pruning
+    # walks every project's trash dir and can take hundreds of ms once trash grows
+    # large; there is no reason to make a session save wait for it. A single flag
+    # prevents overlapping sweeps from piling up when saves happen back-to-back.
+    private def run_cleanup_async
+      return if @cleanup_running
+      @cleanup_running = true
+
+      Clacky::ThreadRegistry.spawn(name: "session-cleanup", daemon: true) do
+        begin
+          cleanup_by_count(keep: 200, grouped_keep: 200)
+          cleanup_trash(days: 8)
+          cleanup_file_trash(days: 8)
+        rescue StandardError
+          # Cleanup is non-critical; swallow file errors but never AgentInterrupted
+        ensure
+          @cleanup_running = false
+        end
+      end
+    end
+
     # Path of the last saved session file.
     def last_saved_path
       @last_saved_path
@@ -337,17 +351,20 @@ module Clacky
     # Returns count of soft-deleted sessions.
     def cleanup_by_count(keep:, grouped_keep: 200)
       # Fast path: if total session files can't exceed any single group's cap,
-      # skip the expensive all_sessions() full-scan (read + JSON.parse every file).
-      # min() is correct because groups are mutually exclusive — any single
-      # group's count ≤ non_pinned ≤ file_count ≤ min(keep, grouped_keep).
-      file_count = Dir.glob(File.join(@sessions_dir, "*.json")).size
-      return 0 if file_count <= [keep, grouped_keep].min
+      # skip the scan entirely. min() is correct because groups are mutually
+      # exclusive — any single group's count ≤ non_pinned ≤ file_count.
+      files = Dir.glob(File.join(@sessions_dir, "*.json"))
+      return 0 if files.size <= [keep, grouped_keep].min
 
-      non_pinned = all_sessions.reject { |s| s[:pinned] }
+      # Read only the header of each file (cheap) instead of parsing the whole
+      # multi-MB payload. The header carries everything we need to rank and
+      # group sessions except project_id, which is resolved lazily below.
+      metas = files.filter_map { |f| m = load_session_metadata(f); m && m.merge(_path: f) }
+                   .sort_by { |s| s[:updated_at] || s[:created_at] || "" }.reverse
 
-      groups = non_pinned.group_by do |s|
-        (s[:project_id] || !GROUPED_SOURCES.include?(s[:source].to_s)) ? "regular" : s[:source].to_s
-      end
+      non_pinned = metas.reject { |s| s[:pinned] }
+
+      groups = non_pinned.group_by { |s| group_key_for(s) }
 
       victims = groups.flat_map do |source, sessions|
         sessions[(source == "regular" ? keep : grouped_keep)..] || []
@@ -357,6 +374,18 @@ module Clacky
       victims.size
     end
 
+    # A session belongs to the "regular" pool unless it is a folded grouped
+    # source (cron/ext) with no project. project_id only matters for cron/ext
+    # sessions, and it lives deep in the file, so we pay for a full parse only
+    # for those — everything else is decided from the cheap header alone.
+    private def group_key_for(meta)
+      source = meta[:source].to_s
+      return "regular" unless GROUPED_SOURCES.include?(source)
+
+      full = load_session_file(meta[:_path])
+      (full && full[:project_id]) ? "regular" : source
+    end
+
     # ── Session trash (delegates to Tools::TrashManager) ──────────────
     # All business logic lives in Clacky::Tools::TrashManager; SessionManager
     # only provides the sessions_dir context and filesystem helpers used there.
@@ -464,6 +493,34 @@ module Clacky
       nil
     end
 
+    # Read only the small scalar header of a session file without parsing the
+    # (potentially multi-MB) messages / time_machine payload. Session JSON is
+    # written with a stable field order, so the fields we care about here
+    # (session_id, pinned, created_at, updated_at, source) always sit in the
+    # first few hundred bytes, before any large array/object. `project_id`
+    # lives much later and is intentionally NOT read — callers that need it
+    # fall back to load_session_file for the rare candidate that requires it.
+    #
+    # Returns a Hash with symbol keys, or nil if the header can't be read.
+    METADATA_HEADER_BYTES = 16 * 1024
+    def load_session_metadata(filepath)
+      head = File.open(filepath, "r") { |f| f.read(METADATA_HEADER_BYTES) }
+      return nil unless head
+
+      sid = head[/"session_id"\s*:\s*"([^"]*)"/, 1]
+      return nil unless sid
+
+      {
+        session_id: sid,
+        pinned:     head[/"pinned"\s*:\s*(true|false)/, 1] == "true",
+        created_at: head[/"created_at"\s*:\s*"([^"]*)"/, 1],
+        updated_at: head[/"updated_at"\s*:\s*"([^"]*)"/, 1],
+        source:     head[/"source"\s*:\s*"([^"]*)"/, 1]
+      }
+    rescue Errno::ENOENT
+      nil
+    end
+
     # Remove Time Machine snapshots that no longer belong to any known session.
     # Snapshots are keyed by full session_id; session files are named by the
     # 8-char id prefix, so a snapshot dir is an orphan when its prefix matches

data/lib/clacky/tools/ask_user.rb

@@ -6,6 +6,7 @@ module Clacky
       self.tool_name = "ask_user"
       self.tool_description = <<~DESC
         Ask the user to choose when you cannot infer the answer and guessing would waste work.
+        Keep every question concise: one sentence, no more than 80 characters.
 
         Every question must have `options` — this tool is for choices, not open prompts.
         Need freeform input (a path, a name)? Just ask in your reply instead.
@@ -27,7 +28,7 @@ module Clacky
               properties: {
                 question: {
                   type: "string",
-                  description: "The question text."
+                  description: "A concise question in one sentence, no more than 80 characters."
                 },
                 description: {
                   type: "string",
@@ -56,7 +57,7 @@ module Clacky
           },
           question: {
             type: "string",
-            description: "Single-question shorthand."
+            description: "Single-question shorthand: one sentence, no more than 80 characters."
           },
           context: {
             type: "string",

data/lib/clacky/tools/terminal.rb

@@ -813,6 +813,9 @@ module Clacky
         spawn_env = {
           "TERM" => "xterm-256color",
           "PS1"  => " ",
+          # PTY makes git/less page interactively; force cat, scoped to our shell only.
+          "GIT_PAGER" => "cat",
+          "PAGER" => "cat",
           # Prevent our sub-shell from polluting the user's ~/.zsh_history
           # (or ~/.bash_history). We fork a full interactive login shell to
           # get rbenv/nvm/brew-shellenv/mise loaded, but every command we
@@ -873,7 +876,8 @@ module Clacky
         end
 
         marker_token = SecureRandom.hex(8)
-        reader_thread = start_reader_thread(reader, log_io)
+        session_box = []
+        reader_thread = start_reader_thread(reader, log_io, session_box)
 
         session = SessionManager.register(
           pid: pid, command: command, cwd: cwd || Dir.pwd,
@@ -883,6 +887,7 @@ module Clacky
           mode: "shell", marker_token: marker_token,
           shell_name: shell_name
         )
+        session_box << session
 
         # Give the shell a moment to print its startup banner (zsh -l -i
         # loads a lot of stuff), then drain whatever noise it wrote so the
@@ -902,8 +907,21 @@ module Clacky
         session
       end
 
-      # Background thread: drain PTY → log file.
-      private def start_reader_thread(reader, log_io)
+      # Background thread: drain PTY → log file. It doubles as the session's
+      # death watcher: when the child exits, read_nonblock raises EIO and the
+      # thread ends up in the ensure block below. Releasing the PTY fds and
+      # forgetting the session there means a dead session's master fd is
+      # reclaimed the moment its child dies — even when the calling agent
+      # never comes back to poll or kill it, which used to leak the fd until
+      # the process hit EMFILE ("Too many open files").
+      #
+      # `session_box` is a one-element array filled by spawn_shell right
+      # after SessionManager.register (the session cannot exist before the
+      # thread starts); an empty box means registration never happened and
+      # spawn_shell itself owns the cleanup. Every close is rescue-guarded
+      # and SessionManager.forget is a plain Hash#delete, so this whole
+      # block is a no-op when the main thread's cleanup_session ran first.
+      private def start_reader_thread(reader, log_io, session_box)
         Clacky::ThreadRegistry.spawn(name: "terminal-pty-reader") do
           loop do
             break if reader.closed? || log_io.closed?
@@ -923,6 +941,15 @@ module Clacky
           end
         ensure
           log_io.close rescue nil
+          if (session = session_box[0])
+            # Flip the status first so a main thread parked in
+            # read_until_marker's poll loop notices the death immediately
+            # (its refresh() no longer finds the session in the registry).
+            session.status = "exited" unless %w[exited killed].include?(session.status)
+            session.writer.close rescue nil
+            session.reader.close rescue nil
+            SessionManager.forget(session.id)
+          end
         end
       end
 

data/lib/clacky/ui2/markdown_renderer.rb

@@ -2,6 +2,7 @@
 
 require "tty-screen"
 require_relative "theme_manager"
+require_relative "strings_cjk_patch"
 
 module Clacky
   module UI2
@@ -21,14 +22,24 @@ module Clacky
           # Get current theme colors
           theme = ThemeManager.current_theme
 
+          width = TTY::Screen.width - 4  # Leave some margin
+
           # Configure tty-markdown with custom theme and symbols
           parsed = TTY::Markdown.parse(content, 
             theme: theme_colors,
             symbols: custom_symbols,
-            width: TTY::Screen.width - 4  # Leave some margin
+            width: width
           )
 
           parsed
+        rescue IndexError => e
+          # Safety net behind strings_cjk_patch; retry uncolored if wrap still fails.
+          warn "[markdown] color render failed (#{e.class}), retrying without color" if ENV["CLACKY_DEBUG"]
+          begin
+            TTY::Markdown.parse(content, color: :never, symbols: custom_symbols, width: width)
+          rescue StandardError
+            content
+          end
         rescue StandardError => e
           warn "[markdown] render failed: #{e.class}: #{e.message}" if ENV["CLACKY_DEBUG"]
           content
@@ -59,20 +70,12 @@ module Clacky
         def theme_colors
           theme = ThemeManager.current_theme
 
-          # Map our theme colors to tty-markdown's expected format
-          # Note: theme.colors values are already arrays, so we need to flatten when adding styles
+          # tty-markdown accepts a single :header key for all header levels
+          # (h1 additionally underlines). Code block colors come from rouge.
           {
-            # Headers use info color (cyan/blue)
-            h1: Array(theme.colors[:info]) + [:bold],
-            h2: Array(theme.colors[:info]) + [:bold],
-            h3: Array(theme.colors[:info]),
-            h4: Array(theme.colors[:info]),
-            h5: Array(theme.colors[:info]),
-            h6: Array(theme.colors[:info]),
+            header: [:bright_cyan, :bold],
             # Horizontal rule - make it subtle (dim gray)
             hr: [:bright_black],
-            # Code blocks use dim color
-            code: Array(theme.colors[:thinking]),
             # Links use success color (green)
             link: Array(theme.colors[:success]),
             # Lists use default text color

data/lib/clacky/ui2/strings_cjk_patch.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "strings"
+
+# strings 0.2.1 (latest release, 2021) tracks ANSI reinsertion offsets in
+# display width (CJK chars count as 2) but applies them as String character
+# indexes via String#insert, so any colored CJK content that needs wrapping
+# raises IndexError. These methods mirror upstream with offsets tracked in
+# character count instead of display width.
+module Strings
+  module Wrap
+    module_function
+
+    def format_line(text_line, wrap_at, ansi_stack)
+      lines = []
+      line  = []
+      word  = []
+      ansi  = []
+      ansi_matched = false
+      word_length = 0
+      line_length = 0
+      word_chars = 0
+      line_chars = 0
+      char_length = 0
+      text_length = display_width(text_line)
+      total_length = 0
+
+      UnicodeUtils.each_grapheme(text_line) do |char|
+        if char == Strings::ANSI::CSI || ansi.length > 0
+          ansi << char
+          if Strings::ANSI.only_ansi?(ansi.join)
+            ansi_matched = true
+          elsif ansi_matched
+            ansi_stack << [ansi[0...-1].join, line_chars + word_chars]
+            ansi_matched = false
+
+            if ansi.last == Strings::ANSI::CSI
+              ansi = [ansi.last]
+            else
+              ansi = []
+            end
+          end
+          next if ansi.length > 0
+        end
+
+        char_length = display_width(char)
+        total_length += char_length
+        if line_length + word_length + char_length <= wrap_at
+          if char == SPACE || total_length == text_length
+            line << word.join + char
+            line_length += word_length + char_length
+            line_chars += word_chars + char.size
+            word = []
+            word_length = 0
+            word_chars = 0
+          else
+            word << char
+            word_length += char_length
+            word_chars += char.size
+          end
+          next
+        end
+
+        if char == SPACE
+          lines << insert_ansi(line.join, ansi_stack)
+          line = []
+          line_length = 0
+          line_chars = 0
+          word << char
+          word_length += char_length
+          word_chars += char.size
+        elsif word_length + char_length <= wrap_at
+          lines << insert_ansi(line.join, ansi_stack)
+          line = [word.join + char]
+          line_length = word_length + char_length
+          line_chars = word_chars + char.size
+          word = []
+          word_length = 0
+          word_chars = 0
+        else # hyphenate word - too long to fit a line
+          lines << insert_ansi(word.join, ansi_stack)
+          line_length = 0
+          line_chars = 0
+          word = [char]
+          word_length = char_length
+          word_chars = char.size
+        end
+      end
+      lines << insert_ansi(line.join, ansi_stack) unless line.empty?
+      lines << insert_ansi(word.join, ansi_stack) unless word.empty?
+      lines
+    end
+
+    def insert_ansi(string, ansi_stack = [])
+      return string if ansi_stack.empty?
+      return string if string.empty?
+
+      new_stack = []
+      output          = string.dup
+      length          = string.size
+      matched_reset   = false
+      ansi_reset      = Strings::ANSI::RESET
+
+      ansi_stack.reverse_each do |ansi|
+        pos = ansi[1]
+        # Offsets carried over from a previous (longer) line can exceed this
+        # line; such codes belong before the wrapped content.
+        pos = 0 if pos > length
+        if ansi[0] =~ /#{Regexp.quote(ansi_reset)}/
+          matched_reset = true
+          output.insert(pos, ansi_reset)
+          next
+        elsif !matched_reset # ansi without reset
+          matched_reset = false
+          new_stack << ansi # keep the ansi
+          next if pos == length
+          if output.end_with?(NEWLINE)
+            output.insert(-2, ansi_reset)
+          else
+            output.insert(-1, ansi_reset)
+          end
+        end
+
+        output.insert(pos, ansi[0])
+      end
+
+      ansi_stack.replace(new_stack)
+
+      output
+    end
+  end
+end

data/lib/clacky/ui2/themes/hacker_theme.rb

@@ -31,7 +31,7 @@ module Clacky
         COLORS = {
           # Format: [symbol_color, dark_bg_text, light_bg_text]
           user: [:bright_black, :white, :black],           # User prompt and input
-          assistant: [:bright_green, :bright_black, :bright_black], # AI response - keep green hacker style
+          assistant: [:bright_green, :bright_white, :black], # AI response
           tool_call: [:bright_cyan, :cyan, :cyan],                # Tool execution
           tool_result: [:bright_cyan, :bright_black, :bright_black], # Tool output
           tool_denied: [:bright_yellow, :yellow, :yellow],        # Denied actions

data/lib/clacky/ui2/themes/minimal_theme.rb

@@ -28,7 +28,7 @@ module Clacky
         COLORS = {
           # Format: [symbol_color, dark_bg_text, light_bg_text]
           user: [:bright_black, :bright_black, :black],           # User prompt and input
-          assistant: [:green, :bright_black, :bright_black],      # AI response
+          assistant: [:green, :bright_white, :black],           # AI response
           tool_call: [:cyan, :cyan, :cyan],                       # Tool execution
           tool_result: [:cyan, :bright_black, :bright_black],     # Tool output
           tool_denied: [:yellow, :yellow, :yellow],               # Denied actions

data/lib/clacky/ui2/ui_controller.rb

@@ -448,7 +448,7 @@ module Clacky
 
       # Show assistant message
       # @param content [String] Message content
-      def show_assistant_message(content, files:, interim: false)
+      def show_assistant_message(content, files:, interim: false, created_at: nil)
         # Filter out thinking tags from models like MiniMax M2.1 that use <think>...</think>
         filtered_content = filter_thinking_tags(content)
         return if filtered_content.nil? || filtered_content.strip.empty?
@@ -629,7 +629,7 @@ module Clacky
       # @param duration [Float] Duration in seconds
       # @param cache_stats [Hash] Cache statistics
       # @param awaiting_user_feedback [Boolean] Whether agent is waiting for user feedback
-      def show_complete(iterations:, cost:, duration: nil, cache_stats: nil, awaiting_user_feedback: false, cost_source: nil)
+      def show_complete(iterations:, cost:, duration: nil, cache_stats: nil, awaiting_user_feedback: false, cost_source: nil, task_id: nil)
         # Update status back to 'idle' when task is complete
         update_sessionbar(status: 'idle')
 

data/lib/clacky/ui_interface.rb

@@ -9,7 +9,7 @@ module Clacky
     # === Output display ===
     # @param content [String] text portion of the assistant reply (file:// links stripped)
     # @param files   [Array<Hash>] extracted file refs: [{ name:, path:, inline: }]
-    def show_assistant_message(content, files:, interim: false); end
+    def show_assistant_message(content, files:, interim: false, created_at: nil); end
     def show_feedback_request(question, context, options, questions: nil); end
     def show_subagent_start(skill: nil, iterations: nil, cost_usd: nil); end
     def show_subagent_end; end
@@ -33,7 +33,7 @@ module Clacky
     # (e.g. /goal auto-switches to auto_approve). UIs that render the mode
     # in a status bar override this.
     def update_permission_mode(mode); end
-    def show_complete(iterations:, cost:, duration: nil, cache_stats: nil, awaiting_user_feedback: false, cost_source: nil); end
+    def show_complete(iterations:, cost:, duration: nil, cache_stats: nil, awaiting_user_feedback: false, cost_source: nil, task_id: nil); end
     def append_output(content); end
 
     # === Status messages ===

data/lib/clacky/utils/model_pricing.rb

@@ -7,6 +7,23 @@ module Clacky
     # Pricing per 1M tokens (MTok) in USD
     # All pricing is based on official API documentation
     PRICING_TABLE = {
+      # Claude Fable 5.1 — same input/output as Fable 5, but cache read is
+      # $0.25/MTok (vs $1.00 for Fable 5). Source: Anthropic pricing table.
+      "claude-fable-5-1" => {
+        input: {
+          default: 10.00,              # $10/MTok for prompts ≤ 200K tokens
+          over_200k: 10.00
+        },
+        output: {
+          default: 50.00,             # $50/MTok for prompts ≤ 200K tokens
+          over_200k: 50.00
+        },
+        cache: {
+          write: 12.50,               # $12.50/MTok cache write (5-min tier)
+          read: 0.25                  # $0.25/MTok cache read
+        }
+      },
+
       # Claude 4.5 models - tiered pricing based on prompt length
       "claude-fable-5" => {
         input: {
@@ -408,6 +425,46 @@ module Clacky
         }
       },
 
+      # Gemini 3.8 Flash. Flat pricing, 1M context, 64K max output.
+      # Same list price as 3.7/3.6 Flash; intro rate $0.75/$3.75 through
+      # 2026-12-31 before settling at $1.50/$7.50 (list price shown).
+      # Cache write billed at input rate (Vertex doesn't expose a separate
+      # cache-write charge in the OpenAI shim usage response).
+      "gemini-3.8-flash" => {
+        input: {
+          default: 1.50,
+          over_200k: 1.50
+        },
+        output: {
+          default: 7.50,
+          over_200k: 7.50
+        },
+        cache: {
+          write: 1.50,
+          read: 0.15
+        }
+      },
+
+      # Gemini 3.7 Flash. Flat pricing, 1M context, 64K max output.
+      # Same list price as 3.6 Flash; both carry an intro rate of $0.75/$3.75
+      # through 2026-12-31 before settling at $1.50/$7.50 (list price shown).
+      # Cache write billed at input rate (Vertex doesn't expose a separate
+      # cache-write charge in the OpenAI shim usage response).
+      "gemini-3.7-flash" => {
+        input: {
+          default: 1.50,
+          over_200k: 1.50
+        },
+        output: {
+          default: 7.50,
+          over_200k: 7.50
+        },
+        cache: {
+          write: 1.50,
+          read: 0.15
+        }
+      },
+
       # Gemini 3.6 Flash (GA 2026-07-21). Flat pricing, 1M context, 64K max output.
       # Source: https://deepmind.google/models/gemini/flash/
       # Cache write billed at input rate (Vertex doesn't expose a separate
@@ -597,6 +654,18 @@ module Clacky
       # GLM-5.3 shares GLM-5.2's base model (all gains are post-training per
       # Z.ai's release notes) and Z.ai's pricing page does not list a separate
       # GLM-5.3 row yet, so it is billed at the GLM-5.2 flat rate.
+      # GLM-5.3-Flash: GLM-5's first natively-multimodal model (image/video/
+      # file input). Listed at the non-promotional Z.ai rates — input $0.15,
+      # output $0.50, cache read $0.03 per 1M tokens; the 50%-off launch promo
+      # ($0.075 / $0.25 / $0.015, ends 2026-09-09) is ignored per the
+      # "displayed ≤ actual" rule. Cache write bills at the input miss rate
+      # (storage is "Limited-time Free").
+      "glm-5.3-flash" => {
+        input:  { default: 0.15, over_200k: 0.15 },
+        output: { default: 0.50, over_200k: 0.50 },
+        cache:  { write: 0.15, read: 0.03 }
+      },
+
       "glm-5.3" => {
         input:  { default: 1.40, over_200k: 1.40 },
         output: { default: 4.40, over_200k: 4.40 },
@@ -704,6 +773,15 @@ module Clacky
       #   - cache.read  = official explicit-cache-hit price.
       #   - When a model has NO published explicit-cache price (e.g. qwen3.6-27b,
       #     qwen-plus-latest), cache.write/read fall back to the input rate.
+      # qwen3.8-max: NOT tiered (single flat tier). Reuses qwen3.7-max's
+      #   international list rates (2.5 / 7.5 / 3.125 / 0.25) — the billing
+      #   page hasn't listed qwen3.8-max yet, so this is a safe upper bound.
+      "qwen3.8-max" => {
+        input:  { default: 2.5, over_200k: 2.5 },
+        output: { default: 7.5, over_200k: 7.5 },
+        cache:  { write: 3.125, read: 0.25 }
+      },
+
       # qwen3.7-max: NOT tiered (single flat tier per Alibaba's definition).
       #   List price: input 2.5, output 7.5, explicit write 3.125, explicit read 0.25.
       "qwen3.7-max" => {
@@ -888,6 +966,8 @@ module Clacky
         # Support both dot and dash separators (e.g., "4.5", "4-5", "4-6")
         # Also handles Bedrock cross-region prefixes (e.g. "jp.anthropic.claude-sonnet-4-6")
         case model
+        when /claude.*fable.*5[.-]1/i
+          "claude-fable-5-1"
         when /claude.*fable.*5/i
           "claude-fable-5"
         # Claude Sonnet 5 / Opus 5 (2026) — anchored on the literal "sonnet-5"
@@ -955,6 +1035,8 @@ module Clacky
         # (mainland bigmodel.cn vs intl z.ai) the user configured.
         # Strict anchored match so unrelated strings like "glm-5-x-foo"
         # don't silently borrow a nearby model's rate.
+        when /^glm-5\.3-flash$/i
+          "glm-5.3-flash"
         when /^glm-5\.3$/i
           "glm-5.3"
         when /^glm-5\.2$/i
@@ -978,10 +1060,12 @@ module Clacky
           "minimax-m2.5"
 
         # Qwen (Alibaba DashScope) — strict anchored match per registered
-        # model id in providers.rb. qwen3.7-* is the latest flagship line;
-        # qwen3.6-* are the previous generation; qwen-plus-latest is the
-        # rolling alias for the latest Qwen-Plus release; qwen3-vl-plus is
-        # the multimodal SKU (replaces the retired qwen-vl-plus/max).
+        # model id in providers.rb. qwen3.8-max is the latest flagship;
+        # qwen3.7-* / qwen3.6-* are previous generations; qwen-plus-latest
+        # is the rolling alias for the latest Qwen-Plus release; qwen3-vl-plus
+        # is the multimodal SKU (replaces the retired qwen-vl-plus/max).
+        when /^qwen3\.8-max$/i
+          "qwen3.8-max"
         when /^qwen3\.7-max$/i
           "qwen3.7-max"
         when /^qwen3\.7-plus$/i
@@ -1007,6 +1091,10 @@ module Clacky
           "gemini-3-flash"
         when /^or-gemini-3-6-flash$/i, /^gemini-3\.6-flash$/i
           "gemini-3.6-flash"
+        when /^or-gemini-3-7-flash$/i, /^gemini-3\.7-flash$/i
+          "gemini-3.7-flash"
+        when /^or-gemini-3-8-flash$/i, /^gemini-3\.8-flash$/i
+          "gemini-3.8-flash"
 
         # OpenAI GPT-5.x models - match various dashed/dotted/compact forms
         # (e.g. "gpt-5.5", "gpt-5-5", "gpt5.5", "gpt55")

data/lib/clacky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clacky
-  VERSION = "1.5.11"
+  VERSION = "1.5.13"
 end