openclacky 0.9.29 → 0.9.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de10c61ed7d2c530c9bdacae8ddc625cfb969d98316f51f45e1833e87ed9b0cb
-  data.tar.gz: 42787ba0901cfc544fde90b46e1a2b4ffe07ce6636bcccbf364141dce3fe0515
+  metadata.gz: 85678c695dcd96512aecef3a290beefa0f08b605a351da12c2db6072d6852147
+  data.tar.gz: 298820c8aabc0a13cb874fa577a5cf12757aa403b804c79d0fa804a5142ecbd0
 SHA512:
-  metadata.gz: 7017db404d793f1cb9483a4a28119f252c8e2e0fd1f183bbe8edf6cf1d1fb5748be2225658dbb666e753499a6694be7c1027e4a448898f22298c5c9bc6d1e2e6
-  data.tar.gz: 406a93802ab41cb68a8c098db3b0777583d888e19f84efa871549832216729ef59899f00512351727a2ceaf0ec209bfc2105061e9e7f050fcfbcca0cf6e50a64
+  metadata.gz: 1d291319e545f25c169341a14e54aa740d17107e2cd97ce39d9285ba7820ba69e3f10f14c15e26e579bfe71d471023be15a6e7ff225131fd77aeb9b916cbcc79
+  data.tar.gz: f89731bd9fc60ca68def237f4cbda3d998dfa306da9419e24b2c3f2dc6cf91c007a80e8bb658685a85d936dab58f246b55bbed7ead92637f0d2b857e645884af

data/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.30] - 2026-04-16
+
+### Added
+- **OpenClacky provider support**: new built-in provider preset for OpenClacky API (https://api.openclacky.com) with Claude Opus 4.6, Sonnet 4.6/4.5, and Haiku 4.5 models
+- **Session chunk index system**: compressed conversation chunks now include a searchable index with topics and turn counts — the agent can selectively load only relevant historical context instead of re-reading all compressed messages, dramatically reducing token usage in long sessions
+- **Provider availability indicator**: Web UI now shows a real-time status badge (Available/Unavailable) next to each provider in the settings modal, helping users quickly identify which services are reachable
+
+### Improved
+- **Progress streaming UX**: API call progress messages (e.g., "Agent is thinking...", compression updates) are now streamed incrementally to the Web UI with better visual feedback and reduced latency
+- **Brand name localization**: brand skill metadata now includes configurable Chinese names (`name_zh`) for better display in localized UIs
+- **Idle timer reliability**: fixed a race condition where old idle timers from previous CLI sessions could continue running after restarting, causing premature auto-saves
+
+### Fixed
+- **Prompt caching in subagents**: subagent tool calls (e.g., skills invoked via `invoke_skill`) now correctly inherit and propagate prompt caching behavior from the parent agent, reducing redundant API costs
+- **WeChat Work Ruby 3.1 compatibility**: fixed `Queue.empty?` crash on Ruby < 3.2 in WeCom channel WebSocket client (method was added in Ruby 3.2.0)
+- **WeChat markdown stripping**: incoming messages from WeChat (Weixin) now preserve original text content when stripping markdown decorators, fixing message corruption where text was accidentally removed
+
 ## [0.9.29] - 2026-04-15
 
 ### Added

data/lib/clacky/agent/llm_caller.rb

@@ -81,10 +81,16 @@ module Clacky
           # infrastructure blips — do NOT trigger fallback.  Just retry on the current
           # model (primary or already-active fallback) up to max_retries.
           if retries <= max_retries
-            @ui&.show_warning("Network failed: #{e.message}. Retry #{retries}/#{max_retries}...")
+            @ui&.show_progress(
+              "Network failed: #{e.message}",
+              progress_type: "retrying",
+              phase: "active",
+              metadata: { attempt: retries, total: max_retries }
+            )
             sleep retry_delay
             retry
           else
+            @ui&.show_progress(progress_type: "retrying", phase: "done")
             @ui&.show_error("Network failed after #{max_retries} retries: #{e.message}")
             raise AgentError, "Network connection failed after #{max_retries} retries: #{e.message}"
           end
@@ -112,10 +118,16 @@ module Clacky
                 retry
               end
             end
-            @ui&.show_warning("#{e.message} (#{retries}/#{current_max})")
+            @ui&.show_progress(
+              e.message,
+              progress_type: "retrying",
+              phase: "active",
+              metadata: { attempt: retries, total: current_max }
+            )
             sleep retry_delay
             retry
           else
+            @ui&.show_progress(progress_type: "retrying", phase: "done")
             @ui&.show_error("LLM service unavailable after #{current_max} retries. Please try again later.")
             raise AgentError, "LLM service unavailable after #{current_max} retries"
           end

data/lib/clacky/agent/message_compressor.rb

@@ -38,16 +38,23 @@ module Clacky
       YOUR ONLY TASK: Create a comprehensive summary of the conversation above.
 
       REQUIRED RESPONSE FORMAT:
-      Your response MUST start with <analysis> or <summary> tags. No other format is acceptable.
+      First output a <topics> line listing 3-6 key topic phrases (comma-separated, concise).
+      Then output the full summary wrapped in <summary> tags.
 
-      Follow the detailed compression prompt structure provided earlier. Focus on:
+      Example format:
+      <topics>Rails setup, database config, deploy pipeline, Tailwind CSS</topics>
+      <summary>
+      ...full summary text...
+      </summary>
+
+      Focus on:
       - User's explicit requests and intents
       - Key technical concepts and code changes
       - Files examined and modified
       - Errors encountered and fixes applied
       - Current work status and pending tasks
 
-      Begin your summary NOW. Remember: PURE TEXT response only, starting with <analysis> or <summary> tags.
+      Begin your response NOW. Remember: PURE TEXT only, starting with <topics> then <summary>.
     PROMPT
 
     def initialize(client, model: nil)
@@ -109,22 +116,33 @@ module Clacky
     end
 
 
+    # Parse topics tag from compressed content.
+    # Returns the topics string if found, nil otherwise.
+    # e.g. "<topics>Rails setup, database config</topics>" → "Rails setup, database config"
+    def parse_topics(content)
+      m = content.match(/<topics>(.*?)<\/topics>/m)
+      m ? m[1].strip : nil
+    end
+
     def parse_compressed_result(result, chunk_path: nil)
       # Return the compressed result as a single assistant message
-      # Keep the <analysis> or <summary> tags as they provide semantic context
+      # Keep the <summary> tags as they provide semantic context
       content = result.to_s.strip
 
       if content.empty?
         []
       else
+        # Strip out the <topics> block — it's metadata for the chunk file, not for AI context
+        content_without_topics = content.gsub(/<topics>.*?<\/topics>\n*/m, "").strip
+
         # Inject chunk anchor so AI knows where to find original conversation
         if chunk_path
           anchor = "\n\n---\n📁 **Original conversation archived at:** `#{chunk_path}`\n" \
                    "_Use `file_reader` tool to recall details from this chunk._"
-          content = content + anchor
+          content_without_topics = content_without_topics + anchor
         end
 
-        [{ role: "assistant", content: content, compressed_summary: true, chunk_path: chunk_path }]
+        [{ role: "assistant", content: content_without_topics, compressed_summary: true, chunk_path: chunk_path }]
       end
     end
   end

data/lib/clacky/agent/message_compressor_helper.rb

@@ -17,9 +17,9 @@ module Clacky
       def trigger_idle_compression
         # Check if we should compress (force mode)
         compression_context = compress_messages_if_needed(force: true)
-        @ui&.show_idle_status(phase: :start, message: "Idle detected. Compressing conversation to optimize costs...")
+        @ui&.show_progress("Idle detected. Compressing conversation to optimize costs...", progress_type: "idle_compress", phase: "active")
         if compression_context.nil?
-          @ui&.show_idle_status(phase: :end, message: "Idle skipped.")
+          @ui&.show_progress("Idle skipped.", progress_type: "idle_compress", phase: "done")
           Clacky::Logger.info(
             "Idle compression skipped",
             enable_compression: @config.enable_compression,
@@ -137,7 +137,8 @@ module Clacky
           original_messages,
           compression_context[:recent_messages],
           chunk_index: chunk_index,
-          compression_level: compression_context[:compression_level]
+          compression_level: compression_context[:compression_level],
+          topics: @message_compressor.parse_topics(compressed_content)
         )
 
         @history.replace_all(@message_compressor.rebuild_with_compression(
@@ -167,7 +168,7 @@ module Clacky
         # Show compression info (use estimated tokens from rebuilt history)
         compression_summary = "History compressed (~#{compression_context[:original_token_count]} -> ~#{@history.estimate_tokens} tokens, " \
           "level #{compression_context[:compression_level]})"
-        @ui&.show_idle_status(phase: :end, message: compression_summary)
+        @ui&.show_progress(compression_summary, progress_type: "idle_compress", phase: "done")
       end
 
       # Get recent messages while preserving tool_calls/tool_results pairs.
@@ -303,16 +304,21 @@ module Clacky
       # @param recent_messages [Array<Hash>] Recent messages being kept (to exclude from chunk)
       # @param chunk_index [Integer] Sequential chunk number
       # @param compression_level [Integer] Compression level
+      # @param topics [String, nil] Short topic description for chunk index card
       # @return [String, nil] Path to saved chunk file, or nil if save failed
-      def save_compressed_chunk(original_messages, recent_messages, chunk_index:, compression_level:)
+      def save_compressed_chunk(original_messages, recent_messages, chunk_index:, compression_level:, topics: nil)
         return nil unless @session_id && @created_at
 
         # Messages being compressed = original minus system message minus recent messages
         # Also exclude system-injected scaffolding (session context, memory prompts, etc.)
         # — these are internal CLI metadata and must not appear in chunk MD or WebUI history.
+        # Also exclude previous compressed_summary messages: they are index cards pointing
+        # to older chunk files and must NOT be embedded inside a new chunk, otherwise
+        # parse_chunk_md_to_rounds would follow the nested reference and create circular
+        # chunk chains (chunk-2 → chunk-1 → ... → chunk-2).
         recent_set = recent_messages.to_a
         messages_to_archive = original_messages.reject do |m|
-          m[:role] == "system" || m[:system_injected] || recent_set.include?(m)
+          m[:role] == "system" || m[:system_injected] || m[:compressed_summary] || recent_set.include?(m)
         end
 
         return nil if messages_to_archive.empty?
@@ -324,7 +330,7 @@ module Clacky
         chunk_filename = "#{base_name}-chunk-#{chunk_index}.md"
         chunk_path = File.join(sessions_dir, chunk_filename)
 
-        md_content = build_chunk_md(messages_to_archive, chunk_index: chunk_index, compression_level: compression_level)
+        md_content = build_chunk_md(messages_to_archive, chunk_index: chunk_index, compression_level: compression_level, topics: topics)
 
         File.write(chunk_path, md_content)
         FileUtils.chmod(0o600, chunk_path)
@@ -339,8 +345,9 @@ module Clacky
       # @param messages [Array<Hash>] Messages to render
       # @param chunk_index [Integer] Chunk number for metadata
       # @param compression_level [Integer] Compression level
+      # @param topics [String, nil] Short topic description extracted from LLM summary
       # @return [String] Markdown content
-      def build_chunk_md(messages, chunk_index:, compression_level:)
+      def build_chunk_md(messages, chunk_index:, compression_level:, topics: nil)
         lines = []
 
         # Front matter
@@ -350,6 +357,7 @@ module Clacky
         lines << "compression_level: #{compression_level}"
         lines << "archived_at: #{Time.now.iso8601}"
         lines << "message_count: #{messages.size}"
+        lines << "topics: #{topics}" if topics
         lines << "---"
         lines << ""
         lines << "# Session Chunk #{chunk_index}"

data/lib/clacky/agent/session_serializer.rb

@@ -529,6 +529,75 @@ module Clacky
           { name: "image_#{idx + 1}.#{ext}", mime_type: mime_type, data_url: url, path: path }
         end
       end
+
+      # Inject a chunk index card into the conversation when archived chunks exist.
+      # Lists all chunk files (path + topics + turn count) so the AI knows where to
+      # look if it needs details from past conversations. The AI can load any chunk
+      # on demand using the existing file_reader tool — no new tools required.
+      #
+      # Only re-injects when a new chunk has been added since the last injection,
+      # keeping the message list clean across multiple compressions.
+      #
+      # Cache-safe: injected as a system_injected user message in the conversation
+      # turns, never touching the system prompt.
+      def inject_chunk_index_if_needed
+        # Collect all compressed_summary messages that carry a chunk_path
+        chunk_msgs = @history.to_a.select { |m| m[:compressed_summary] && m[:chunk_path] }
+        return if chunk_msgs.empty?
+
+        # Skip if we already injected an index for this exact chunk count
+        return if @history.last_injected_chunk_count == chunk_msgs.size
+
+        # Remove any previously injected chunk index (stale — chunk count changed)
+        @history.delete_where { |m| m[:chunk_index] }
+
+        # Build index card lines
+        lines = ["## Previous Session Archives (#{chunk_msgs.size} chunk#{"s" if chunk_msgs.size > 1} available)\n"]
+        chunk_msgs.each_with_index do |msg, i|
+          path   = msg[:chunk_path].to_s
+          topics = read_chunk_topics(path)
+          turns  = read_chunk_message_count(path)
+          lines << "[CHUNK-#{i + 1}] #{path}"
+          lines << "  Topics: #{topics}" if topics
+          lines << "  Turns: #{turns}"   if turns
+          lines << ""
+        end
+        lines << "Use file_reader to load a chunk file when you need original conversation details."
+
+        @history.append({
+          role: "user",
+          content: lines.join("\n"),
+          system_injected: true,
+          chunk_index: true,
+          chunk_count: chunk_msgs.size
+        })
+      end
+
+      # Read the `topics` field from a chunk MD file's YAML front matter.
+      # Returns nil if the file is missing or has no topics field.
+      private def read_chunk_topics(chunk_path)
+        return nil unless chunk_path && File.exist?(chunk_path)
+        File.foreach(chunk_path) do |line|
+          return line.sub(/^topics:\s*/, "").strip if line.start_with?("topics:")
+          break if line.strip == "---" && $. > 1  # end of front matter
+        end
+        nil
+      rescue
+        nil
+      end
+
+      # Read the `message_count` field from a chunk MD file's YAML front matter.
+      # Returns nil if the file is missing or has no message_count field.
+      private def read_chunk_message_count(chunk_path)
+        return nil unless chunk_path && File.exist?(chunk_path)
+        File.foreach(chunk_path) do |line|
+          return line.sub(/^message_count:\s*/, "").strip.to_i if line.start_with?("message_count:")
+          break if line.strip == "---" && $. > 1
+        end
+        nil
+      rescue
+        nil
+      end
     end
   end
 end

data/lib/clacky/agent/skill_manager.rb

@@ -255,7 +255,7 @@ module Clacky
           transient: transient
         })
 
-        @ui&.show_info("Injected skill content for /#{skill.identifier}#{skill.name_zh ? " (#{skill.name_zh})" : ""}")
+        @ui&.show_info("Injected skill content for /#{skill.identifier}#{skill.name_zh.to_s.empty? ? "" : " (#{skill.name_zh})"}")
       end
 
 
@@ -405,7 +405,7 @@ module Clacky
 
         # Log which model the subagent is actually using (may differ from requested
         # when "lite" falls back to default due to no lite model configured)
-        @ui&.show_info("Subagent start: #{skill.identifier}#{skill.name_zh ? " (#{skill.name_zh})" : ""} [#{subagent.current_model_info[:model]}]")
+        @ui&.show_info("Subagent start: #{skill.identifier}#{skill.name_zh.to_s.empty? ? "" : " (#{skill.name_zh})"} [#{subagent.current_model_info[:model]}]")
 
         # Run subagent with the actual task as the sole user turn.
         # If the user typed the skill command with no arguments (e.g. "/jade-appraisal"),

data/lib/clacky/agent.rb

@@ -212,6 +212,9 @@ module Clacky
       # Inject session context (date + model) if not yet present or date has changed
       inject_session_context_if_needed
 
+      # Inject chunk index card if archived chunks exist and index is stale
+      inject_chunk_index_if_needed
+
       # Split files into vision images and disk files; downgrade oversized images to disk
       image_files, disk_files = partition_files(Array(files))
       vision_images, downgraded = resolve_vision_images(image_files)

data/lib/clacky/brand_config.rb

@@ -664,11 +664,36 @@ module Clacky
           # installed and that have a newer version available.
           # New skills are never auto-installed — the user must click Install/Update
           # explicitly from the Brand Skills panel.
+          installed = installed_brand_skills
           skills_needing_update = result[:skills].select { |s| s["needs_update"] }
           results = skills_needing_update.map do |skill_info|
             install_brand_skill!(skill_info)
           end
 
+          # Even when the version hasn't changed, display metadata (name_zh,
+          # description_zh, description) may have been updated on the platform.
+          # Patch brand_skills.json in-place without re-downloading the ZIP.
+          result[:skills].each do |skill_info|
+            name = skill_info["name"]
+            next unless installed.key?(name)
+            next if skill_info["needs_update"] # already being reinstalled above
+
+            local = installed[name]
+            next if local["name_zh"]        == skill_info["name_zh"].to_s &&
+                    local["description_zh"] == skill_info["description_zh"].to_s &&
+                    local["description"]    == skill_info["description"].to_s
+
+            # Metadata changed — update brand_skills.json without reinstalling.
+            record_installed_skill(
+              name,
+              local["version"],
+              skill_info["description"].to_s,
+              encrypted:      local["encrypted"] != false,
+              description_zh: skill_info["description_zh"].to_s,
+              name_zh:        skill_info["name_zh"].to_s
+            )
+          end
+
           on_complete&.call(results)
         rescue StandardError
           # Background sync failures are intentionally swallowed — the agent

data/lib/clacky/cli.rb

@@ -709,8 +709,21 @@ module Clacky
             sleep 0.1
             # Clear output area
             ui_controller.layout.clear_output
+            # Cancel old idle timer before replacing agent to avoid stale-agent compression
+            idle_timer.cancel
             # Clear session by creating a new agent
             agent = Clacky::Agent.new(client, agent_config, working_dir: working_dir, ui: ui_controller, profile: agent.agent_profile.name, session_id: Clacky::SessionManager.generate_id, source: :manual)
+            # Rebuild idle timer bound to the new agent
+            idle_timer = Clacky::IdleCompressionTimer.new(
+              agent:           agent,
+              session_manager: session_manager,
+              logger:          ->(msg, level:) { ui_controller.log(msg, level: level) }
+            ) do |success|
+              if success
+                ui_controller.update_sessionbar(tasks: agent.total_tasks, cost: agent.total_cost)
+              end
+              ui_controller.set_idle_status
+            end
             ui_controller.show_info("Session cleared. Starting fresh.")
             # Update session bar with reset values
             ui_controller.update_sessionbar(tasks: agent.total_tasks, cost: agent.total_cost)

data/lib/clacky/client.rb

@@ -114,12 +114,25 @@ module Clacky
 
     # ── Prompt-caching support ────────────────────────────────────────────────
 
-    # Returns true for Claude 3.5+ models that support prompt caching.
+    # Returns true for Claude models that support prompt caching (gen 3.5+ or gen 4+).
+    #
+    # Handles both direct model names (e.g. "claude-haiku-4-5") and
+    # Clacky AI Bedrock proxy names with "abs-" prefix (e.g. "abs-claude-haiku-4-5").
+    #
+    # Why only Claude models:
+    #   - MiniMax uses automatic server-side caching (no cache_control needed from client)
+    #   - Kimi uses a proprietary prompt_cache_key param, not cache_control
+    #   - MiMo has no documented caching API
+    #   - Only Claude (direct, OpenRouter, or ClackyAI Bedrock proxy) consumes our
+    #     cache_control / cachePoint markers
     def supports_prompt_caching?(model)
-      model_str = model.to_s.downcase
+      # Strip ClackyAI Bedrock proxy prefix before matching
+      model_str = model.to_s.downcase.sub(/^abs-/, "")
       return false unless model_str.include?("claude")
 
-      model_str.match?(/claude(?:-3[-.]?[5-9]|-[4-9]|-sonnet-[34])/)
+      # Match Claude gen 3.5+ (3.5/3.6/3.7…) or gen 4+ in any name format:
+      #   claude-3.5-sonnet-...  claude-3-7-sonnet  claude-haiku-4-5  claude-sonnet-4-6
+      model_str.match?(/claude(?:-3[-.]?[5-9]|.*-[4-9][-.]|.*-[4-9]$|-[4-9][-.]|-[4-9]$|-sonnet-[34])/)
     end
 
 

data/lib/clacky/json_ui_controller.rb

@@ -97,10 +97,6 @@ module Clacky
       emit("info", message: message)
     end
 
-    def show_idle_status(phase:, message:)
-      emit("idle_status", phase: phase.to_s, message: message)
-    end
-
     def show_warning(message)
       emit("warning", message: message)
     end
@@ -119,15 +115,25 @@ module Clacky
 
     # === Progress ===
 
-    def show_progress(message = nil, prefix_newline: true, output_buffer: nil)
-      @progress_start_time = Time.now
-      emit("progress", message: message, status: "start")
+    def show_progress(message = nil, prefix_newline: true, progress_type: "thinking", phase: "active", metadata: {})
+      @progress_start_time = Time.now if phase == "active"
+      
+      data = {
+        message: message,
+        progress_type: progress_type,
+        phase: phase,
+        status: phase == "active" ? "start" : "stop"  # backward compat
+      }
+      data[:metadata] = metadata unless metadata.empty?
+      data[:elapsed] = (Time.now - @progress_start_time).round(1) if phase == "done" && @progress_start_time
+      
+      emit("progress", **data)
+      
+      @progress_start_time = nil if phase == "done"
     end
 
     def clear_progress
-      elapsed = @progress_start_time ? (Time.now - @progress_start_time).round(1) : 0
-      @progress_start_time = nil
-      emit("progress", status: "stop", elapsed: elapsed)
+      show_progress(progress_type: "thinking", phase: "done")
     end
 
     # === State updates ===

data/lib/clacky/message_history.rb

@@ -12,6 +12,7 @@ module Clacky
       task_id created_at system_injected session_context memory_update
       subagent_instructions subagent_result token_usage
       compressed_summary chunk_path truncated transient
+      chunk_index chunk_count
     ].freeze
 
     def initialize(messages = [])
@@ -123,6 +124,13 @@ module Clacky
       msg&.dig(:session_date)
     end
 
+    # Return the chunk_count from the most recently injected chunk index message.
+    # Used by inject_chunk_index_if_needed to avoid re-injecting when nothing changed.
+    def last_injected_chunk_count
+      msg = @messages.reverse.find { |m| m[:chunk_index] }
+      msg&.dig(:chunk_count) || 0
+    end
+
     # Return only real (non-system-injected) user messages.
     def real_user_messages
       @messages.select { |m| m[:role] == "user" && !m[:system_injected] }

data/lib/clacky/plain_ui_controller.rb

@@ -87,11 +87,6 @@ module Clacky
       puts_line("[info] #{message}")
     end
 
-    def show_idle_status(phase:, message:)
-      # In plain mode, just print the final state
-      puts_line("[info] #{message}") if phase.to_s == "end"
-    end
-
     def show_warning(message)
       puts_line("[warn] #{message}")
     end
@@ -111,7 +106,7 @@ module Clacky
 
     # === Progress (no-ops — no spinner in plain mode) ===
 
-    def show_progress(message = nil, prefix_newline: true, output_buffer: nil); end
+    def show_progress(message = nil, prefix_newline: true, progress_type: "thinking", phase: "active", metadata: {}); end
     def clear_progress; end
 
     # === State updates (no-ops) ===

data/lib/clacky/providers.rb

@@ -11,13 +11,31 @@ module Clacky
     # - api: API type (anthropic-messages, openai-responses, openai-completions)
     # - default_model: Recommended default model
     PRESETS = {
+      "openclacky" => {
+        "name" => "OpenClacky",
+        "base_url" => "https://api.openclacky.com",
+        "api" => "bedrock",
+        "default_model" => "abs-claude-sonnet-4-5",
+        "lite_model" => "abs-claude-haiku-4-5",
+        "models" => [
+          "abs-claude-opus-4-6",
+          "abs-claude-sonnet-4-6",
+          "abs-claude-sonnet-4-5",
+          "abs-claude-haiku-4-5"
+        ],
+        # Fallback chain: if a model is unavailable, try the next one in order.
+        # Keys are primary model names; values are the fallback model to use instead.
+        "fallback_models" => {
+          "abs-claude-sonnet-4-6" => "abs-claude-sonnet-4-5"
+        },
+        "website_url" => "https://www.openclacky.com/ai-keys"
+      }.freeze,
 
       "openrouter" => {
         "name" => "OpenRouter",
         "base_url" => "https://openrouter.ai/api/v1",
         "api" => "openai-responses",
         "default_model" => "anthropic/claude-sonnet-4-6",
-        "lite_model" => "anthropic/claude-haiku-4-5",
         "models" => [],  # Dynamic - fetched from API
         "website_url" => "https://openrouter.ai/keys"
       }.freeze,
@@ -49,15 +67,16 @@ module Clacky
         "website_url" => "https://console.anthropic.com/settings/keys"
       }.freeze,
 
-      "clackyai" => {
-        "name" => "ClackyAI",
+      "clackyai-sea" => {
+        "name" => "ClackyAI( Sea )",
         "base_url" => "https://api.clacky.ai",
         "api" => "bedrock",
-        "default_model" => "abs-claude-sonnet-4-6",
+        "default_model" => "abs-claude-sonnet-4-5",
         "lite_model" => "abs-claude-haiku-4-5",
         "models" => [
           "abs-claude-opus-4-6",
           "abs-claude-sonnet-4-6",
+          "abs-claude-sonnet-4-5",
           "abs-claude-haiku-4-5"
         ],
         # Fallback chain: if a model is unavailable, try the next one in order.

data/lib/clacky/server/channel/adapters/wecom/ws_client.rb

@@ -361,7 +361,9 @@ module Clacky
 
             send_frame(cmd: cmd, req_id: req_id, body: body)
 
-            result = queue.pop(timeout: 30)
+            timeout_thread = Thread.new { sleep 30; queue.push(nil) }
+            result = queue.pop
+            timeout_thread.kill
             raise "Timeout waiting for ack (req_id=#{req_id}, cmd=#{cmd})" if result.nil?
 
             errcode = result["errcode"] || result.dig("body", "errcode")

data/lib/clacky/server/channel/adapters/weixin/adapter.rb

@@ -417,11 +417,11 @@ module Clacky
             r = text.dup
             r.gsub!(/```[^\n]*\n?([\s\S]*?)```/) { Regexp.last_match(1).strip }
             r.gsub!(/!\[[^\]]*\]\([^)]*\)/, "")
-            r.gsub!(/\[([^\]]+)\]\([^)]*\)/, '')
-            r.gsub!(/\*\*([^*]+)\*\*/, '')
-            r.gsub!(/\*([^*]+)\*/, '')
-            r.gsub!(/__([^_]+)__/, '')
-            r.gsub!(/_([^_]+)_/, '')
+            r.gsub!(/\[([^\]]+)\]\([^)]*\)/, '\\1')
+            r.gsub!(/\*\*([^*]+)\*\*/, '\\1')
+            r.gsub!(/\*([^*]+)\*/, '\\1')
+            r.gsub!(/__([^_]+)__/, '\\1')
+            r.gsub!(/_([^_]+)_/, '\\1')
             r.gsub!(/^#+\s+/, "")
             r.gsub!(/^[-*_]{3,}\s*$/, "")
             r.strip

data/lib/clacky/server/web_ui_controller.rb

@@ -208,13 +208,25 @@ module Clacky
 
       # === Progress ===
 
-      def show_progress(message = nil, prefix_newline: true, output_buffer: nil)
-        @progress_start_time = Time.now
+      def show_progress(message = nil, prefix_newline: true, progress_type: "thinking", phase: "active", metadata: {})
+        @progress_start_time = Time.now if phase == "active"
         @live_progress_message = message
         # Reset stdout buffer for each new command so re-subscribe only replays current run
-        @live_stdout_buffer = []
-        emit("progress", message: message, status: "start")
+        @live_stdout_buffer = [] if phase == "active"
+        
+        data = {
+          message: message,
+          progress_type: progress_type,
+          phase: phase,
+          status: phase == "active" ? "start" : "stop"  # backward compat
+        }
+        data[:metadata] = metadata unless metadata.empty?
+        data[:elapsed] = (Time.now - @progress_start_time).round(1) if phase == "done" && @progress_start_time
+        
+        emit("progress", **data)
         forward_to_subscribers { |sub| sub.show_progress(message) }
+        
+        @progress_start_time = nil if phase == "done"
       end
 
       # Stream shell stdout/stderr lines to the browser while a command is running.
@@ -230,14 +242,10 @@ module Clacky
       end
 
       def clear_progress
-        elapsed = @progress_start_time ? (Time.now - @progress_start_time).round(1) : 0
-        @progress_start_time = nil
-        @live_progress_message = nil
         @live_tool_call = nil   # command finished — nothing left to replay
         # Keep @live_stdout_buffer intact — it will be reset on the next show_progress call.
         # This allows a brief replay window even after the command finishes.
-        emit("progress", status: "stop", elapsed: elapsed)
-        forward_to_subscribers { |sub| sub.clear_progress }
+        show_progress(progress_type: "thinking", phase: "done")
       end
 
       # Replay in-progress command state to a newly (re-)subscribing browser tab.

data/lib/clacky/ui2/ui_controller.rb

@@ -466,8 +466,7 @@ module Clacky
       # Show progress indicator with dynamic elapsed time
       # @param message [String] Progress message (optional, will use random thinking verb if nil)
       # @param prefix_newline [Boolean] Whether to add a blank line before progress (default: true)
-      # @param output_buffer [Hash, nil] Shared output buffer for real-time command output (optional)
-      def show_progress(message = nil, prefix_newline: true, output_buffer: nil)
+      def show_progress(message = nil, prefix_newline: true, progress_type: "thinking", phase: "active", metadata: {})
         # Stop any existing progress thread
         stop_progress_thread
 
@@ -476,7 +475,6 @@ module Clacky
 
         @progress_message = message || Clacky::THINKING_VERBS.sample
         @progress_start_time = Time.now
-        @progress_output_buffer = output_buffer
         # Flag used by the progress thread to know when to stop gracefully.
         # Using a flag + join is safe because Thread#kill can interrupt a thread
         # while it holds @render_mutex, causing a permanent deadlock.
@@ -562,7 +560,6 @@ module Clacky
 
         # Signal thread to stop without joining — it will exit on next loop tick
         @progress_start_time = nil
-        @progress_output_buffer = nil
         @stdout_lines = nil
         @progress_thread_stop = true
         # Detach: let the thread die on its own; we do NOT join here
@@ -594,7 +591,6 @@ module Clacky
       # @render_mutex) and leave the mutex permanently locked.
       def stop_progress_thread
         @progress_start_time = nil
-        @progress_output_buffer = nil
         @progress_thread_stop = true
         if @progress_thread&.alive?
           # Join with a short timeout; fall back to kill only as a last resort

data/lib/clacky/ui_interface.rb

@@ -30,7 +30,11 @@ module Clacky
     def log(message, level: :info); end
 
     # === Progress ===
-    def show_progress(message = nil, prefix_newline: true, output_buffer: nil); end
+    # Unified progress indicator with type-based display customization.
+    # progress_type: "thinking" | "retrying" | "idle_compress" | custom
+    # phase: "active" | "done"
+    # metadata: extensible hash (e.g., {attempt: 3, total: 10} for retries)
+    def show_progress(message = nil, prefix_newline: true, progress_type: "thinking", phase: "active", metadata: {}); end
     def clear_progress; end
 
     # === State updates ===
@@ -39,12 +43,6 @@ module Clacky
     def set_working_status; end
     def set_idle_status; end
 
-    # === Idle compression status ===
-    # Emits a two-phase idle compression status update.
-    # phase: :start  → show "Idle detected. Compressing..." (with spinner)
-    # phase: :end    → update same element with final result (skipped / compressed)
-    def show_idle_status(phase:, message:); end
-
     # === Blocking interaction ===
     def request_confirmation(message, default: true); end
 

data/lib/clacky/version.rb

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

data/lib/clacky/web/app.css

@@ -2012,6 +2012,14 @@ body {
   padding: 4px 0;
 }
 
+.skill-ac-empty {
+  padding: 14px 16px;
+  font-size: 13px;
+  color: var(--color-text-tertiary, #888);
+  text-align: left;
+  font-style: italic;
+}
+
 .skill-ac-item {
   display: flex;
   align-items: baseline;

data/lib/clacky/web/app.js

@@ -292,6 +292,7 @@ function showConfirmModal(confId, message) {
 let _initialRestoreDone = false;
 
 WS.onEvent(ev => {
+  console.log("[DEBUG] WS event received:", ev.type, ev);
   switch (ev.type) {
 
     // ── Internal WS lifecycle ──────────────────────────────────────────
@@ -446,9 +447,17 @@ WS.onEvent(ev => {
       break;
 
     case "progress":
+      console.log("[DEBUG] progress event:", ev);
       if (ev.session_id !== Sessions.activeId) break;
-      if (ev.status === "start") Sessions.showProgress(ev.message || I18n.t("chat.thinking"));
-      else Sessions.clearProgress();
+      if (ev.phase === "active" || ev.status === "start") {
+        const progress_type = ev.progress_type || "thinking";
+        const metadata = ev.metadata || {};
+        console.log("[DEBUG] calling showProgress:", { message: ev.message, progress_type, metadata });
+        Sessions.showProgress(ev.message, progress_type, metadata);
+      } else {
+        console.log("[DEBUG] calling clearProgress:", ev.message);
+        Sessions.clearProgress(ev.message);
+      }
       break;
 
     case "complete":
@@ -471,17 +480,16 @@ WS.onEvent(ev => {
       break;
 
     // ── Info / errors ──────────────────────────────────────────────────
-    case "idle_status":
-      // Two-phase: "start" shows a spinner line, "end" updates it in-place
-      Sessions.updateIdleStatus(ev.phase, ev.message);
-      break;
-
     case "info":
       Sessions.appendInfo(ev.message);
       break;
 
     case "warning":
-      Sessions.appendInfo("⚠ " + ev.message);
+      // Optimize retry messages for better UX
+      const friendlyWarning = _transformRetryWarning(ev.message);
+      if (friendlyWarning) {
+        Sessions.appendInfo(friendlyWarning);
+      }
       break;
 
     case "success":
@@ -1204,11 +1212,21 @@ const SkillAC = (() => {
 
     _items = scored.map(({ skill }) => skill);
 
-    if (_items.length === 0) { _hide(); return; }
-
     const list = $("skill-autocomplete-list");
     list.innerHTML = "";
 
+    if (_items.length === 0) {
+      // Show empty state instead of hiding the dropdown
+      const emptyEl = document.createElement("div");
+      emptyEl.className = "skill-ac-empty";
+      emptyEl.textContent = I18n.t("skills.ac.empty");
+      list.appendChild(emptyEl);
+      $("skill-autocomplete").style.display = "";
+      _visible = true;
+      _createOverlay();
+      return;
+    }
+
     _items.forEach((skill, idx) => {
       const item = document.createElement("div");
       item.className = "skill-ac-item" + (idx === _activeIndex ? " active" : "");

data/lib/clacky/web/i18n.js

@@ -35,6 +35,7 @@ const I18n = (() => {
       "chat.input.placeholder": "Message… (Enter to send, Shift+Enter for newline)",
       "chat.btn.send":       "Send",
       "chat.thinking":       "Thinking…",
+      "chat.retrying":       "Retrying",
       "chat.history_load_failed": "Could not load history",
       "chat.history_start":       "No more history",
       "chat.image_expired": "Expired",
@@ -188,6 +189,7 @@ const I18n = (() => {
       "skills.toggle.disableDesc":  "AI can auto-invoke. Disable to prevent auto-triggering (manual use still available)",
       "skills.toggle.enableDesc":   "AI cannot auto-invoke. Enable to allow auto-triggering",
       "skills.toggleError":         "Error: ",
+      "skills.ac.empty":            "No skills available",
       "skills.upload.uploading":    "Uploading…",
       "skills.upload.uploaded":     "Uploaded",
       "skills.upload.upload":       "Upload",
@@ -362,6 +364,7 @@ const I18n = (() => {
       "chat.input.placeholder": "输入消息…（Enter 发送，Shift+Enter 换行）",
       "chat.btn.send":       "发送",
       "chat.thinking":       "思考中…",
+      "chat.retrying":       "正在重试",
       "chat.history_load_failed": "历史记录加载失败",
       "chat.history_start":       "没有更多历史了",
       "chat.image_expired": "已过期",
@@ -515,6 +518,7 @@ const I18n = (() => {
       "skills.toggle.disableDesc":  "AI 可自动调用。关闭后 AI 不会主动触发（手动使用仍可用）",
       "skills.toggle.enableDesc":   "AI 不会自动调用。开启后允许 AI 主动触发",
       "skills.toggleError":         "错误：",
+      "skills.ac.empty":            "暂无可用技能",
       "skills.upload.uploading":    "上传中…",
       "skills.upload.uploaded":     "已上传",
       "skills.upload.upload":       "上传",
@@ -740,3 +744,56 @@ const I18n = (() => {
   // ── Public API ─────────────────────────────────────────────────────────────
   return { lang, setLang, t, applyAll };
 })();
+
+// ── Thinking Verbs for Progress Animation ──────────────────────────────────
+const THINKING_VERBS = {
+  en: [
+    "Cogitating",
+    "Pondering",
+    "Ruminating",
+    "Deliberating",
+    "Contemplating",
+    "Flibbertigibbeting",
+    "Percolating",
+    "Noodling",
+    "Brewing",
+    "Marinating",
+    "Stewing",
+    "Mulling",
+    "Processing",
+    "Computing",
+    "Calculating",
+    "Analyzing",
+    "Synthesizing",
+    "Ideating",
+    "Brainstorming",
+    "Reasoning"
+  ],
+  zh: [
+    "思考中",
+    "琢磨中",
+    "推敲中",
+    "酝酿中",
+    "沉思中",
+    "冥想中",
+    "盘算中",
+    "权衡中",
+    "构思中",
+    "揣摩中",
+    "运算中",
+    "分析中",
+    "综合中",
+    "理解中",
+    "头脑风暴中",
+    "推理中",
+    "整理思绪中",
+    "组织语言中"
+  ]
+};
+
+// Get a random thinking verb based on current language
+function getRandomThinkingVerb() {
+  const lang = I18n.lang();
+  const verbs = THINKING_VERBS[lang] || THINKING_VERBS.en;
+  return verbs[Math.floor(Math.random() * verbs.length)];
+}

data/lib/clacky/web/sessions.js

@@ -1314,52 +1314,81 @@ const Sessions = (() => {
       _scrollToBottomIfNeeded(messages);
     },
 
-    // Two-phase idle compression status — renders as a single line that updates in-place.
-    // phase "start": create element with spinner; phase "end": update same element with result.
-    updateIdleStatus(phase, text) {
-      const messages = $("messages");
-      if (phase === "start") {
-        Sessions.collapseToolGroup();
-        const el = document.createElement("div");
-        el.className   = "msg msg-info msg-idle-status";
-        el.textContent = "⟳ " + text;
-        messages.appendChild(el);
-        Sessions._idleStatusEl = el;
-      } else {
-        // phase "end" — update existing element or create a new one if start was missed
-        if (Sessions._idleStatusEl) {
-          Sessions._idleStatusEl.textContent = "· " + text;
-          Sessions._idleStatusEl.classList.add("msg-idle-done");
-          Sessions._idleStatusEl = null;
-        } else {
-          Sessions.appendInfo("· " + text);
-        }
-      }
-      _scrollToBottomIfNeeded(messages);
-    },
-
-    _idleStatusEl: null,
+    _progressEl: null,
+    _progressInterval: null,
+    _progressStartTime: null,
+    _progressType: null,
 
-    showProgress(text) {
+    showProgress(text, progress_type = "thinking", metadata = {}) {
+      console.log("[DEBUG] showProgress called:", { text, progress_type, metadata });
       Sessions.clearProgress();
+      
+      Sessions._progressType = progress_type;
+      Sessions._progressStartTime = Date.now();
+      
       const messages = $("messages");
       const el = document.createElement("div");
-      el.className   = "progress-msg";
-      el.textContent = "⟳ " + text;
+      el.className = "progress-msg";
+      
+      // Choose display text based on type
+      let displayText;
+      if (progress_type === "thinking") {
+        displayText = text || getRandomThinkingVerb();
+        console.log("[DEBUG] thinking verb:", displayText);
+      } else if (progress_type === "retrying") {
+        const { attempt, total } = metadata;
+        // Show error reason + retry count
+        if (text && attempt && total) {
+          displayText = `${I18n.t("chat.retrying")}: ${text} (${attempt}/${total})`;
+        } else if (attempt && total) {
+          displayText = `${I18n.t("chat.retrying")} (${attempt}/${total})`;
+        } else {
+          displayText = text || I18n.t("chat.retrying");
+        }
+      } else if (progress_type === "idle_compress") {
+        displayText = text || "Compressing...";
+      } else {
+        displayText = text || I18n.t("chat.thinking");
+      }
+      
+      el.textContent = "⟳ " + displayText;
+      console.log("[DEBUG] appending progress element:", el.textContent);
       messages.appendChild(el);
       Sessions._progressEl = el;
       _scrollToBottomIfNeeded(messages);
+      
+      // Start elapsed time counter (update every second)
+      Sessions._progressInterval = setInterval(() => {
+        const elapsed = Math.floor((Date.now() - Sessions._progressStartTime) / 1000);
+        if (Sessions._progressEl) {
+          Sessions._progressEl.textContent = `⟳ ${displayText}… (${elapsed}s)`;
+        }
+      }, 1000);
     },
 
-    clearProgress() {
+    clearProgress(finalMessage = null) {
+      console.log("[DEBUG] clearProgress called:", finalMessage);
+      // Clear interval timer
+      if (Sessions._progressInterval) {
+        clearInterval(Sessions._progressInterval);
+        Sessions._progressInterval = null;
+      }
+      
+      // Remove progress element
       if (Sessions._progressEl) {
         Sessions._progressEl.remove();
         Sessions._progressEl = null;
       }
+      
+      // Show final message if provided (for idle_compress, etc.)
+      if (finalMessage && Sessions._progressType !== "thinking") {
+        Sessions.appendInfo(`· ${finalMessage}`);
+      }
+      
+      Sessions._progressStartTime = null;
+      Sessions._progressType = null;
     },
 
-    _progressEl: null,
-
     // ── Create ─────────────────────────────────────────────────────────────
 
     /** Create a new session and navigate to it. */

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openclacky
 version: !ruby/object:Gem::Version
-  version: 0.9.29
+  version: 0.9.30
 platform: ruby
 authors:
 - windy