openclacky 0.9.29 → 0.9.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de10c61ed7d2c530c9bdacae8ddc625cfb969d98316f51f45e1833e87ed9b0cb
-  data.tar.gz: 42787ba0901cfc544fde90b46e1a2b4ffe07ce6636bcccbf364141dce3fe0515
+  metadata.gz: eb05bb9cc5c24901331584bde84b85b264536fa838001bcf113f41df5a96dbce
+  data.tar.gz: a8bde52bacb92f46a894582ad9b00afa2a325323b464194fbbd744a4cbbddc77
 SHA512:
-  metadata.gz: 7017db404d793f1cb9483a4a28119f252c8e2e0fd1f183bbe8edf6cf1d1fb5748be2225658dbb666e753499a6694be7c1027e4a448898f22298c5c9bc6d1e2e6
-  data.tar.gz: 406a93802ab41cb68a8c098db3b0777583d888e19f84efa871549832216729ef59899f00512351727a2ceaf0ec209bfc2105061e9e7f050fcfbcca0cf6e50a64
+  metadata.gz: 3684277987068171be446db5ab6efa3fe33304714d963cd757cc2102477911a13dc2b68f7dec2952d020f1bfd6427d8510469214dcdc8c1e8666995c93ddb098
+  data.tar.gz: 7a84b5fc71f3beb237ed07475bd7a72dac6162c9b519e732e1aba2cafe0af05e3d8f1a4d90e3ec857a084a158113720213a873ea73c997ebb553eea39e61964a

data/CHANGELOG.md

@@ -7,6 +7,43 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.31] - 2026-04-18
+
+### Added
+- GLM (智谱) model provider support — select GLM models directly from the provider settings
+- Claude Opus 4.7 model option in the built-in provider list
+- Skill Creator UI — create and edit skills from the Web interface with a visual editor
+- Interactive feedback cards — `request_user_feedback` now renders as a styled interactive card in all UIs (Web, UI2, plain), instead of plain text
+- Brand deactivation — white-label brand can now be toggled on/off from the settings page
+- Empty skill placeholder — shows a friendly message when no skills are installed yet
+
+### Improved
+- Shell tool large output handling — when a shell command waits for input or times out with large output, the output is now properly truncated and saved to temp files so the agent can still read the full content
+- Chinese UI translations expanded with new thinkverbose labels
+
+### Fixed
+- Bedrock streaming truncation recovery — when a tool call's arguments are truncated by the API, the broken assistant message is now retracted from history and the agent retries cleanly instead of crashing
+- First session scroll position in the Web UI sidebar
+- Idle status indicator in UI2
+- Channels page spacing and skill creator label alignment in Web UI
+
+## [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

@@ -414,7 +414,8 @@ module Clacky
                 parts = []
                 parts << "**Context:** #{context.strip}" << "" unless context.strip.empty?
                 parts << "**Question:** #{question.strip}"
-                if options && !options.empty?
+                # Guard: options must be an Array to iterate with each_with_index
+                if options.is_a?(Array) && !options.empty?
                   parts << "" << "**Options:**"
                   options.each_with_index { |opt, i| parts << "  #{i + 1}. #{opt}" }
                 end
@@ -529,6 +530,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)
@@ -695,11 +698,13 @@ module Clacky
             @ui&.update_todos(@todos.dup)
           end
 
-          # Special handling for request_user_feedback: show directly as message
+          # Special handling for request_user_feedback: emit as interactive feedback card
           if call[:name] == "request_user_feedback"
-            if result.is_a?(Hash) && result[:message]
-              @ui&.show_assistant_message(result[:message], files: [])
-            end
+            # Pass the raw call arguments to show_tool_call so the WebUI controller
+            # can extract question/context/options and emit a "request_feedback" event
+            # (renders as a clickable card in the browser).
+            # Fallback UIs (terminal, IM channels) receive the formatted text message.
+            @ui&.show_tool_call(call[:name], call[:arguments])
 
             if @config.permission_mode == :auto_approve
               # auto_approve means no human is watching (unattended/scheduled tasks).
@@ -731,6 +736,17 @@ module Clacky
           }
           Clacky::Logger.error("tool_execution_error", tool: call[:name], error: e)
 
+          # If arguments were malformed/truncated (e.g. Bedrock streaming truncation),
+          # retract the bad assistant message from history so the next LLM call gets a
+          # fresh context rather than re-reading a cached broken tool call.
+          # Also skip adding a tool_result — without the assistant message there is no
+          # tool_call to pair with, and sending an orphan tool_result breaks the API.
+          if e.is_a?(Utils::BadArgumentsError)
+            size_before = @history.size
+            @history.pop_while { |m| m[:role] == "assistant" && m[:tool_calls]&.any? { |tc| tc[:id] == call[:id] } }
+            next if @history.size < size_before # message was retracted, skip tool_result
+          end
+
           @hooks.trigger(:on_tool_error, call, e)
           @ui&.show_tool_error(e)
           # Use build_denied_result with system_injected=true so LLM knows it can retry

data/lib/clacky/brand_config.rb

@@ -135,6 +135,29 @@ module Clacky
       FileUtils.chmod(0o600, BRAND_FILE)
     end
 
+    # Remove the local license binding and wipe all brand-related fields from disk.
+    # Brand skills installed from this license are also cleared.
+    # Returns { success: true }.
+    def deactivate!
+      clear_brand_skills!
+      FileUtils.rm_f(BRAND_FILE)
+      # Reset all in-memory state so this instance is clean after the call.
+      @product_name           = nil
+      @package_name           = nil
+      @logo_url               = nil
+      @support_contact        = nil
+      @support_qr_url         = nil
+      @theme_color            = nil
+      @homepage_url           = nil
+      @license_key            = nil
+      @license_activated_at   = nil
+      @license_expires_at     = nil
+      @license_last_heartbeat = nil
+      @license_user_id        = nil
+      @device_id              = nil
+      { success: true }
+    end
+
     # Activate the license against the OpenClacky Cloud API using HMAC proof.
     # Returns a result hash: { success: bool, message: String, data: Hash }
     def activate!(license_key)
@@ -664,11 +687,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/default_skills/onboard/SKILL.md

@@ -41,21 +41,21 @@ Example (Chinese):
 ### 2. Ask the user to name the AI (card)
 
 Call `request_user_feedback` to let the user pick or type a name for their AI assistant.
-Offer a few fun suggestions as options, plus a free-text fallback.
+Offer a few fun suggestions as options. The user can also ignore the options and type any name directly.
 
 If `lang == "zh"`, use:
 ```json
 {
-  "question": "先来点有意思的 —— 你想叫我什么名字？可以选一个，也可以直接输入你喜欢的：",
-  "options": ["🐟 摸鱼王", "📚 卷王", "🌟 小天才", "🐱 本喵", "🌅 拾光", "自己输入名字…"]
+  "question": "先来点有意思的 —— 你想叫我什么名字？",
+  "options": ["摸鱼王", "老六", "夜猫子", "话唠", "包打听", "碎碎念", "掌柜的"]
 }
 ```
 
 Otherwise (English):
 ```json
 {
-  "question": "Let's start with something fun — what would you like to call me? Pick one or type your own:",
-  "options": ["✨ Aria", "🤖 Max", "🌙 Luna", "⚡ Zap", "🎯 Ace", "Type your own name…"]
+  "question": "Let's start with something fun — what would you like to call me?",
+  "options": ["Nox", "Sable", "Remy", "Vex", "Pip", "Zola", "Bex"]
 }
 ```
 
@@ -108,7 +108,11 @@ Call `request_user_feedback` again. This is where we learn about the user themse
 If `lang == "zh"`, use:
 ```json
 {
-  "question": "那你呢？随便聊聊自己吧 —— 全部可选，填多少都行：\n• 你的名字（我该怎么称呼你？）\n• 职业\n• 最希望用 AI 做什么\n• 社交 / 作品链接（GitHub、微博、个人网站等）—— 我会读取公开信息来更了解你",
+  "question": "那你呢？随便聊聊自己吧 —— 全部可选，填多少都行：
+- 你的名字（我该怎么称呼你？）
+- 职业
+- 最希望用 AI 做什么
+- 社交 / 作品链接（GitHub、微博、个人网站等）—— 我会读取公开信息来更了解你",
   "options": []
 }
 ```
@@ -116,7 +120,11 @@ If `lang == "zh"`, use:
 Otherwise (English):
 ```json
 {
-  "question": "Now a bit about you — all optional, skip anything you like.\n• Your name (what should I call you?)\n• Occupation\n• What you want to use AI for most\n• Social / portfolio links (GitHub, Twitter/X, personal site…) — I'll read them to learn about you",
+  "question": "Now a bit about you — all optional, skip anything you like.
+- Your name (what should I call you?)
+- Occupation
+- What you want to use AI for most
+- Social / portfolio links (GitHub, Twitter/X, personal site…) — I'll read them to learn about you",
   "options": []
 }
 ```

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] }