openclacky 0.9.30 → 0.9.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85678c695dcd96512aecef3a290beefa0f08b605a351da12c2db6072d6852147
-  data.tar.gz: 298820c8aabc0a13cb874fa577a5cf12757aa403b804c79d0fa804a5142ecbd0
+  metadata.gz: a4dd6332b6e7425bea0dd817603ad5af83e4d23b5742b79f5ca97f2d0fc18a0c
+  data.tar.gz: 640788854a81c8760999e866dce8364c6e2547603098f24582f6b6b51837797b
 SHA512:
-  metadata.gz: 1d291319e545f25c169341a14e54aa740d17107e2cd97ce39d9285ba7820ba69e3f10f14c15e26e579bfe71d471023be15a6e7ff225131fd77aeb9b916cbcc79
-  data.tar.gz: f89731bd9fc60ca68def237f4cbda3d998dfa306da9419e24b2c3f2dc6cf91c007a80e8bb658685a85d936dab58f246b55bbed7ead92637f0d2b857e645884af
+  metadata.gz: 96423895e7df89b17c5eb7196aca0f829e1f5544c14def222d888faddb35a39c78f3df1bdea40d3ce884c9d3edf7b3a4ac8f8447e5ab7394e569ed9d9ffd8038
+  data.tar.gz: 2f85e85244ddfa8720a9c2cf6fc053d68671e051ce0d2ccafbbb01581b3fc460e1c7cd10c4a05dc93a88614c3f6505e61aaa4510f821a283a39974069f2694a6

data/CHANGELOG.md

@@ -7,6 +7,44 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.32] - 2026-04-20
+
+### Added
+- **Skill auto-evolution system**: after completing a complex task (12+ iterations) without an existing skill, the agent automatically analyzes whether the workflow is worth capturing as a reusable skill and creates one via `skill-creator` if it meets the criteria
+- **Skill reflection**: after executing a skill via slash command, the agent reflects on whether the skill's instructions could be improved and updates it automatically if concrete improvements are found
+
+### Improved
+- **Shell tool output management**: shell tool now uses `LimitStack` for output buffering — per-line character limits, total character budgets, and rolling-window line caps are all enforced in a single, well-tested utility, replacing ad-hoc truncation logic
+- **Progress display**: cleaned up progress/spinner lifecycle — all UIs (Web, CLI, UI2, channel) now use a unified `show_progress done` pattern instead of a separate `clear_progress` call, eliminating stale spinners
+
+### Fixed
+- **Thinking state bleed across sessions**: in the Web UI, a "thinking" indicator from a previous session no longer bleeds into a freshly opened session
+- **Token truncation reliability**: improved agent token-limit handling — context trimming now uses a cleaner single-pass approach and removes the dependency on per-message character counting in `MessageHistory`
+- **Skill auto-creation crash**: fixed `nil.to_a` error in `SkillAutoCreator` when conversation history contained messages without tool calls
+
+### More
+- Updated platform HTTP client fallback host for improved connectivity reliability
+
+## [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

data/lib/clacky/agent/llm_caller.rb

@@ -68,7 +68,7 @@ module Clacky
           handle_probe_success if @config.probing?
 
         rescue Faraday::ConnectionFailed, Faraday::TimeoutError, Faraday::SSLError, Errno::ECONNREFUSED, Errno::ETIMEDOUT => e
-          @ui&.clear_progress
+          @ui&.show_progress(phase: "done")
           retries += 1
 
           # Probing failure: primary still down — renew cooling-off and retry with fallback.
@@ -90,13 +90,13 @@ module Clacky
             sleep retry_delay
             retry
           else
-            @ui&.show_progress(progress_type: "retrying", phase: "done")
+            @ui&.show_progress(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
 
         rescue RetryableError => e
-          @ui&.clear_progress
+          @ui&.show_progress(phase: "done")
           retries += 1
 
           # Probing failure: primary still down — renew cooling-off and retry with fallback.
@@ -127,13 +127,13 @@ module Clacky
             sleep retry_delay
             retry
           else
-            @ui&.show_progress(progress_type: "retrying", phase: "done")
+            @ui&.show_progress(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
 
         ensure
-          @ui&.clear_progress
+          @ui&.show_progress(phase: "done")
         end
 
         # Track cost and collect token usage data.

data/lib/clacky/agent/memory_updater.rb

@@ -62,7 +62,7 @@ module Clacky
         @history.delete_where { |m| m[:memory_update] }
         @memory_prompt_injected = false
         @memory_updating = false
-        @ui&.clear_progress
+        @ui&.show_progress(phase: "done")
       end
 
       private def memory_update_enabled?

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

data/lib/clacky/agent/skill_auto_creator.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Clacky
+  class Agent
+    # Scenario 1: Auto-create new skills from complex task patterns.
+    #
+    # After completing a complex task (high iteration count, no existing skill used),
+    # inject a system prompt asking the LLM to analyze if the workflow is reusable
+    # and worth capturing as a new skill.
+    #
+    # If the LLM determines it's valuable, it can invoke skill-creator in "quick mode"
+    # to generate a new skill automatically.
+    module SkillAutoCreator
+      # Default minimum iterations to consider auto-creating a skill
+      DEFAULT_AUTO_CREATE_THRESHOLD = 12
+
+      # Check if we should prompt the LLM to consider creating a new skill
+      # Called from SkillEvolution#run_skill_evolution_hooks
+      def maybe_create_skill_from_task
+        return unless should_auto_create_skill?
+
+        inject_skill_creation_prompt
+      end
+
+      # Determine if this task is a candidate for skill auto-creation
+      # @return [Boolean]
+      private def should_auto_create_skill?
+        threshold = skill_evolution_config[:auto_create_threshold] || DEFAULT_AUTO_CREATE_THRESHOLD
+
+        # Conditions (ALL must be true):
+        # 1. Task was complex enough (high iteration count)
+        # 2. No skill was explicitly invoked (not a skill refinement session)
+        # 3. Task succeeded (not an error state)
+
+        @iterations >= threshold &&
+          !@skill_execution_context &&
+          !skill_invoked_in_history?
+      end
+
+      # Check if any skill was invoked during this task
+      # Looks for invoke_skill tool calls in the conversation history
+      # @return [Boolean]
+      private def skill_invoked_in_history?
+        @history.to_a.any? { |msg|
+          msg[:role] == "assistant" &&
+            msg[:tool_calls]&.any? { |tc| tc[:name] == "invoke_skill" }
+        }
+      end
+
+      # Inject skill creation prompt as a system message
+      # The LLM will analyze and decide whether to create a new skill
+      private def inject_skill_creation_prompt
+        @history.append({
+          role: "user",
+          content: build_skill_creation_prompt,
+          system_injected: true,
+          skill_auto_create: true
+        })
+
+        @ui&.show_info("Analyzing task for skill creation opportunity...")
+      end
+
+      # Build the skill auto-creation prompt content
+      # @return [String]
+      private def build_skill_creation_prompt
+        <<~PROMPT
+          ═══════════════════════════════════════════════════════════════
+          SKILL AUTO-CREATION MODE
+          ═══════════════════════════════════════════════════════════════
+          You just completed a complex task (#{@iterations} iterations) without using any existing skill.
+
+          ## Analysis
+
+          Review the conversation history and determine:
+          - Is this workflow likely to be reused in similar future tasks?
+          - Does it have a clear input → process → output pattern?
+          - Would it save significant time if automated as a skill?
+
+          ## Decision Criteria (ALL must be true)
+
+          1. **Reusable**: The workflow could apply to similar tasks in the future
+             (not a one-off, project-specific task)
+          2. **Well-defined**: Clear steps with consistent logic, not just exploratory conversation
+          3. **Valuable**: Would save more than 5 minutes of work if reused
+          4. **Generalizable**: Can be parameterized for different inputs/contexts
+
+          ## Action
+
+          If **ALL** criteria are met:
+            → Call invoke_skill with:
+               - skill_name: "skill-creator"
+               - task: A clear description of what to automate and how (be specific)
+               - mode: "quick" (enables fast auto-creation without user interviews)
+               - suggested_name: A descriptive identifier (lowercase, hyphens OK)
+
+          Example invocation:
+          ```
+          invoke_skill(
+            skill_name: "skill-creator",
+            task: "Create a skill to extract and summarize content from URLs. The skill should: 1) fetch the URL content, 2) parse the main text, 3) generate a concise summary. Expected input: URL. Expected output: markdown summary.",
+            mode: "quick",
+            suggested_name: "url-summarizer"
+          )
+          ```
+
+          If **NOT all** criteria are met:
+            → Respond briefly: "This task doesn't warrant a new skill." (no tool calls)
+
+          ## Constraints
+
+          - Be selective: Don't create skills for one-off tasks or project-specific workflows
+          - Be specific: When creating a skill, clearly describe the workflow steps
+          - Keep it simple: Focus on the core happy path, edge cases can be added later
+          - Prefer generalization: The skill should work across different contexts
+        PROMPT
+      end
+    end
+  end
+end

data/lib/clacky/agent/skill_evolution.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Clacky
+  class Agent
+    # Unified entry point for skill self-evolution system.
+    # Coordinates two scenarios:
+    #   1. Auto-create new skills from complex task patterns
+    #   2. Reflect on executed skills and suggest improvements
+    #
+    # Triggered at the end of Agent#run (post-run hooks), only for main agents.
+    module SkillEvolution
+      # Main entry point - runs all skill evolution checks
+      # Called from Agent#run after the main loop completes
+      def run_skill_evolution_hooks
+        return unless skill_evolution_enabled?
+        return if @is_subagent
+
+        # Scenario 2: Reflect on executed skill (if one just ran)
+        maybe_reflect_on_skill if @skill_execution_context
+
+        # Scenario 1: Auto-create new skill from complex task
+        maybe_create_skill_from_task
+      end
+
+      # Check if skill evolution is enabled in config
+      # @return [Boolean]
+      private def skill_evolution_enabled?
+        # Default to true if not explicitly disabled
+        return true unless @config.respond_to?(:skill_evolution)
+
+        config = @config.skill_evolution
+        return true if config.nil?
+
+        config[:enabled] != false
+      end
+
+      # Get skill evolution configuration hash
+      # @return [Hash]
+      private def skill_evolution_config
+        return {} unless @config.respond_to?(:skill_evolution)
+
+        @config.skill_evolution || {}
+      end
+    end
+  end
+end

data/lib/clacky/agent/skill_manager.rb

@@ -200,6 +200,14 @@ module Clacky
       # @param task_id [Integer] Current task ID (for message tagging)
       # @return [void]
       def inject_skill_as_assistant_message(skill, arguments, task_id, slash_command: false)
+        # Track skill execution context for self-evolution system
+        @skill_execution_context = {
+          skill_name: skill.identifier,
+          start_iteration: @iterations,
+          arguments: arguments,
+          slash_command: slash_command
+        }
+
         # For encrypted brand skills with supporting scripts: decrypt to a tmpdir so the
         # LLM receives the real paths it can execute. The tmpdir is registered on the agent
         # and shredded when agent.run completes (see Agent#shred_script_tmpdirs).

data/lib/clacky/agent/skill_reflector.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Clacky
+  class Agent
+    # Scenario 2: Reflect on skill execution and suggest improvements.
+    #
+    # After a skill completes, inject a system prompt asking the LLM to analyze:
+    #   - Were instructions clear enough?
+    #   - Any missing edge cases?
+    #   - Any improvements needed?
+    #
+    # If the LLM identifies concrete improvements, it can invoke skill-creator
+    # to update the skill.
+    module SkillReflector
+      # Minimum iterations for a skill execution to warrant reflection.
+      # Raised to 5 to filter out lightweight skill invocations (e.g. platform
+      # management skills like cron-task-creator that the user triggered incidentally).
+      MIN_SKILL_ITERATIONS = 5
+
+      # Check if we should reflect on the skill that just executed
+      # Called from SkillEvolution#run_skill_evolution_hooks
+      def maybe_reflect_on_skill
+        return unless @skill_execution_context
+
+        # Only reflect on skills that the user explicitly invoked via slash command.
+        # Skills triggered by the LLM itself (e.g. as part of a broader task) or
+        # platform-management skills invoked incidentally should not be reflected on.
+        return unless @skill_execution_context[:slash_command]
+
+        skill_name = @skill_execution_context[:skill_name]
+        start_iteration = @skill_execution_context[:start_iteration]
+        iterations = @iterations - start_iteration
+
+        # Only reflect if the skill actually ran for a meaningful number of iterations
+        return if iterations < MIN_SKILL_ITERATIONS
+
+        inject_skill_reflection_prompt(skill_name, iterations)
+
+        # Clear the context so we don't reflect again
+        @skill_execution_context = nil
+      end
+
+      # Inject reflection prompt into history as a system message
+      # The LLM will respond in the next user interaction (non-blocking)
+      #
+      # @param skill_name [String] Identifier of the skill that was executed
+      # @param iterations [Integer] Number of iterations the skill ran for
+      private def inject_skill_reflection_prompt(skill_name, iterations)
+        @history.append({
+          role: "user",
+          content: build_skill_reflection_prompt(skill_name, iterations),
+          system_injected: true,
+          skill_reflection: true
+        })
+
+        @ui&.show_info("Reflecting on skill execution: #{skill_name}")
+      end
+
+      # Build the reflection prompt content
+      # @param skill_name [String]
+      # @param iterations [Integer]
+      # @return [String]
+      private def build_skill_reflection_prompt(skill_name, iterations)
+        <<~PROMPT
+          ═══════════════════════════════════════════════════════════════
+          SKILL REFLECTION MODE
+          ═══════════════════════════════════════════════════════════════
+          You just executed the skill "#{skill_name}" over #{iterations} iterations.
+
+          ## Quick Analysis
+
+          Reflect on whether the skill could be improved:
+          - Were the instructions clear enough?
+          - Did you encounter any edge cases not covered?
+          - Were there any steps that could be streamlined?
+          - Is there missing context that would make it easier next time?
+          - Did the skill produce the expected results?
+
+          ## Decision
+
+          If you identified **concrete, actionable improvements**:
+            → Call invoke_skill("skill-creator", task: "Improve skill #{skill_name}: [describe specific improvements needed]")
+
+          If the skill worked well as-is:
+            → Respond briefly: "Skill #{skill_name} worked well, no improvements needed."
+
+          ## Constraints
+
+          - DO NOT spend more than 30 seconds on this reflection
+          - Be specific and actionable in your improvement suggestions
+          - Only suggest improvements that would make a meaningful difference
+          - If you're unsure, err on the side of "no improvements needed"
+        PROMPT
+      end
+    end
+  end
+end

data/lib/clacky/agent.rb

@@ -20,6 +20,9 @@ require_relative "agent/system_prompt_builder"
 require_relative "agent/llm_caller"
 require_relative "agent/time_machine"
 require_relative "agent/memory_updater"
+require_relative "agent/skill_evolution"
+require_relative "agent/skill_reflector"
+require_relative "agent/skill_auto_creator"
 
 module Clacky
   class Agent
@@ -33,6 +36,9 @@ module Clacky
     include LlmCaller
     include TimeMachine
     include MemoryUpdater
+    include SkillEvolution
+    include SkillReflector
+    include SkillAutoCreator
 
     attr_reader :session_id, :name, :history, :iterations, :total_cost, :working_dir, :created_at, :total_tasks, :todos,
                 :cache_stats, :cost_source, :ui, :skill_loader, :agent_profile,
@@ -174,6 +180,7 @@ module Clacky
       task_id = start_new_task
 
       @start_time = Time.now
+      @task_truncation_count = 0  # Reset truncation counter for each task
       @task_cost_source = :estimated  # Reset for new task
       # Note: Do NOT reset @previous_total_tokens here - it should maintain the value from the last iteration
       # across tasks to correctly calculate delta tokens in each iteration
@@ -408,6 +415,11 @@ module Clacky
         save_modified_files_snapshot(@modified_files_in_task)
         @modified_files_in_task = []  # Reset for next task
       end
+
+        # Run skill evolution hooks after main loop completes
+        # Only for main agent (not subagents) to avoid recursive evolution
+        run_skill_evolution_hooks unless @is_subagent
+
         if @is_subagent
           # Parent agent (skill_manager) prints the completion summary; skip here.
         else
@@ -499,9 +511,9 @@ module Clacky
       # Handle truncated responses (when max_tokens limit is reached)
       if response[:finish_reason] == "length"
         # Count recent truncations to prevent infinite loops
-        recent_truncations = @history.recent_truncation_count(5)
+        @task_truncation_count = (@task_truncation_count || 0) + 1
 
-        if recent_truncations >= 2
+        if @task_truncation_count >= 3
           # Too many truncations - task is too complex
           @ui&.show_error("Response truncated multiple times. Task is too complex.")
 
@@ -525,18 +537,30 @@ module Clacky
           return error_response
         end
 
+        # Preserve the truncated assistant message (text only, drop incomplete tool_calls)
+        # so the LLM sees what it attempted before. This also maintains the required
+        # user/assistant alternation for Bedrock Converse API.
+        truncated_text = response[:content] || ""
+        truncated_text = "..." if truncated_text.strip.empty?
+        @history.append({
+          role: "assistant",
+          content: truncated_text,
+          task_id: @current_task_id
+        })
+
         # Insert system message to guide LLM to retry with smaller steps
         @history.append({
           role: "user",
-          content: "[SYSTEM] Your response was truncated due to length limit. Please retry with a different approach:\n" \
-                   "- For long file content: create the file with structure first, then use edit() to add content section by section\n" \
-                   "- Break down large tasks into multiple smaller steps\n" \
-                   "- Avoid putting more than 2000 characters in a single tool call argument\n" \
+          content: "[SYSTEM] Your previous response was truncated because it exceeded the output token limit (max_tokens=#{@config.max_tokens}). " \
+                   "The incomplete tool call has been discarded. Please retry with a different approach:\n" \
+                   "- For long file content: create the file with a basic structure first, then use edit() to add content section by section\n" \
+                   "- Break down large tasks into multiple smaller tool calls\n" \
+                   "- Keep each tool call argument under 2000 characters\n" \
                    "- Use multiple tool calls instead of one large call",
           truncated: true
         })
 
-        @ui&.show_warning("Response truncated. Retrying with smaller steps...")
+        @ui&.show_warning("Response truncated (#{@task_truncation_count}/3). Retrying with smaller steps...")
 
         # Recursively retry
         return think
@@ -684,7 +708,7 @@ module Clacky
               progress_timer.kill
               progress_timer.join
             end
-            @ui&.clear_progress if progress_shown
+            @ui&.show_progress(phase: "done") if progress_shown
           end
 
           # Track modified files for Time Machine snapshots
@@ -698,11 +722,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).

data/lib/clacky/agent_config.rb

@@ -152,7 +152,8 @@ module Clacky
 
     attr_accessor :permission_mode, :max_tokens, :verbose,
                   :enable_compression, :enable_prompt_caching,
-                  :models, :current_model_index
+                  :models, :current_model_index,
+                  :memory_update_enabled, :skill_evolution
 
     def initialize(options = {})
       @permission_mode = validate_permission_mode(options[:permission_mode])
@@ -165,6 +166,14 @@ module Clacky
       # Models configuration
       @models = options[:models] || []
       @current_model_index = options[:current_model_index] || 0
+
+      # Memory and skill evolution configuration
+      @memory_update_enabled = options[:memory_update_enabled].nil? ? true : options[:memory_update_enabled]
+      @skill_evolution = options[:skill_evolution] || {
+        enabled: true,
+        auto_create_threshold: 12,
+        reflection_mode: "llm_analysis"
+      }
     end
 
     # Load configuration from file

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)

data/lib/clacky/cli.rb

@@ -471,7 +471,7 @@ module Clacky
 
       # Handle agent error/interrupt with cleanup
       def handle_agent_exception(ui_controller, agent, session_manager, exception)
-        ui_controller.clear_progress
+        ui_controller.show_progress(phase: "done")
         ui_controller.set_idle_status
 
         if exception.is_a?(Clacky::AgentInterrupted)

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/default_skills/personal-website/publish.rb

@@ -25,7 +25,7 @@ require "fileutils"
 # Primary CDN-accelerated endpoint.
 # Fallback bypasses EdgeOne and is used when the primary times out or errors.
 PRIMARY_HOST  = ENV.fetch("CLACKY_LICENSE_SERVER", "https://www.openclacky.com")
-FALLBACK_HOST = "https://openclacky-platform.clackyai.app"
+FALLBACK_HOST = "https://openclacky.up.railway.app"
 # When the env override is set we use only that host (dev/test mode).
 API_HOSTS     = ENV["CLACKY_LICENSE_SERVER"] ? [PRIMARY_HOST] : [PRIMARY_HOST, FALLBACK_HOST]