openclacky 0.9.31 → 0.9.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb05bb9cc5c24901331584bde84b85b264536fa838001bcf113f41df5a96dbce
-  data.tar.gz: a8bde52bacb92f46a894582ad9b00afa2a325323b464194fbbd744a4cbbddc77
+  metadata.gz: a4dd6332b6e7425bea0dd817603ad5af83e4d23b5742b79f5ca97f2d0fc18a0c
+  data.tar.gz: 640788854a81c8760999e866dce8364c6e2547603098f24582f6b6b51837797b
 SHA512:
-  metadata.gz: 3684277987068171be446db5ab6efa3fe33304714d963cd757cc2102477911a13dc2b68f7dec2952d020f1bfd6427d8510469214dcdc8c1e8666995c93ddb098
-  data.tar.gz: 7a84b5fc71f3beb237ed07475bd7a72dac6162c9b519e732e1aba2cafe0af05e3d8f1a4d90e3ec857a084a158113720213a873ea73c997ebb553eea39e61964a
+  metadata.gz: 96423895e7df89b17c5eb7196aca0f829e1f5544c14def222d888faddb35a39c78f3df1bdea40d3ce884c9d3edf7b3a4ac8f8447e5ab7394e569ed9d9ffd8038
+  data.tar.gz: 2f85e85244ddfa8720a9c2cf6fc053d68671e051ce0d2ccafbbb01581b3fc460e1c7cd10c4a05dc93a88614c3f6505e61aaa4510f821a283a39974069f2694a6

data/CHANGELOG.md

@@ -7,6 +7,24 @@ 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

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/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
@@ -736,17 +760,6 @@ 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/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/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/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]
 

data/lib/clacky/default_skills/skill-creator/SKILL.md

@@ -7,6 +7,15 @@ description: Create new skills, modify and improve existing skills, and measure
 
 A skill for creating new skills and iteratively improving them.
 
+## Usage Modes
+
+This skill supports two modes:
+
+### 1. Interactive Mode (default)
+
+The full workflow with user interviews, test cases, and iteration cycles.
+Use when creating or refining skills manually.
+
 At a high level, the process of creating a skill goes like this:
 
 - Decide what you want the skill to do and roughly how it should do it
@@ -22,6 +31,43 @@ Your job is to figure out where the user is in this process and jump in to help
 
 Always be flexible. If the user says "skip the evals, just vibe with me", do that instead.
 
+### 2. Quick Mode (for agent self-evolution)
+
+**Trigger**: When invoked with `mode: "quick"` in the task arguments.
+
+Fast, opinionated skill creation without user interaction. This mode is used by the agent's self-evolution system to automatically create or improve skills.
+
+**Behavior**:
+- Skip user interviews and detailed requirements gathering
+- Extract workflow pattern from provided context
+- Write a minimal but functional SKILL.md
+- Save to `~/.clacky/skills/auto-<name>-<timestamp>/` (or improve existing skill in place)
+- Skip test cases and evals (user can refine later if needed)
+- Always validate frontmatter with the validator script after creation
+- Focus on the happy path; edge cases can be added later
+
+**Expected arguments when using quick mode**:
+- `task`: Clear description of what to automate and how (be specific about workflow steps)
+- `mode`: Must be set to `"quick"`
+- `suggested_name`: (optional) Proposed skill identifier (lowercase, hyphens OK)
+
+**Quick mode principles**:
+- **Be opinionated**: Make reasonable assumptions without asking
+- **Be concise**: Keep instructions simple and focused
+- **Be practical**: Focus on the core workflow that will save the most time
+- **Be correct**: Always set `disable-model-invocation: false` and `user-invocable: true`
+- **Be validating**: Run the frontmatter validator immediately after creation
+
+**Example invocation from the agent's self-evolution system**:
+```
+invoke_skill(
+  skill_name: "skill-creator",
+  task: "Create a skill to extract and summarize content from URLs. The skill should: 1) fetch the URL using safe_shell with curl, 2) parse the HTML to extract main text content, 3) generate a concise markdown summary. Expected input: URL string. Expected output: markdown summary with title and key points.",
+  mode: "quick",
+  suggested_name: "url-summarizer"
+)
+```
+
 ---
 
 ## Platform Context: Clacky

data/lib/clacky/json_ui_controller.rb

@@ -132,10 +132,6 @@ module Clacky
       @progress_start_time = nil if phase == "done"
     end
 
-    def clear_progress
-      show_progress(progress_type: "thinking", phase: "done")
-    end
-
     # === State updates ===
 
     def update_sessionbar(tasks: nil, cost: nil, status: nil)

data/lib/clacky/message_history.rb

@@ -62,12 +62,6 @@ module Clacky
       @messages.pop
     end
 
-    # Remove messages from the end while the block is truthy.
-    def pop_while(&block)
-      @messages.pop while !@messages.empty? && block.call(@messages.last)
-      self
-    end
-
     # Remove all messages matching the block in-place
     # (e.g. cleanup_memory_messages uses reject! { m[:memory_update] }).
     def delete_where(&block)
@@ -152,12 +146,6 @@ module Clacky
       @messages.select { |m| !m[:task_id] || m[:task_id] <= task_id }
     end
 
-    # Count how many of the last N messages have :truncated set.
-    # Used by think() to guard against infinite truncation retry loops.
-    def recent_truncation_count(n)
-      @messages.last(n).count { |m| m[:truncated] }
-    end
-
     # ─────────────────────────────────────────────
     # Size helpers
     # ─────────────────────────────────────────────

data/lib/clacky/plain_ui_controller.rb

@@ -126,7 +126,6 @@ module Clacky
     # === Progress (no-ops — no spinner in plain mode) ===
 
     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/platform_http_client.rb

@@ -9,8 +9,6 @@ module Clacky
   # OpenClacky platform API (www.openclacky.com and its fallback domain).
   #
   # Features:
-  #   - Primary domain:  https://www.openclacky.com  (EdgeOne CDN-accelerated)
-  #   - Fallback domain: https://openclacky-platform.clackyai.app  (direct, no CDN)
   #   - Automatic retry with exponential back-off on transient failures
   #   - Transparent domain failover: if the primary domain times out or returns a
   #     5xx error, the request is automatically retried against the fallback domain
@@ -23,9 +21,9 @@ module Clacky
   #   #        or { success: false, error: "...", data: {} }
   class PlatformHttpClient
     # Primary CDN-accelerated endpoint
-    PRIMARY_HOST   = "https://www.openclacky.com"
+    PRIMARY_HOST  = "https://www.openclacky.com"
     # Direct fallback — bypasses EdgeOne, used when the primary times out
-    FALLBACK_HOST  = "https://openclacky-platform.clackyai.app"
+    FALLBACK_HOST = "https://openclacky.up.railway.app"
 
     # Number of attempts per domain (1 = no retry within the same domain)
     ATTEMPTS_PER_HOST = 2