openclacky 0.9.34 → 0.9.35

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52f436f4aa95f2360172d33a3f6703b9106f9568d1c805fbc26248e9b483834c
-  data.tar.gz: 42469a3ba3c357420b036fc4d877875e030e4dfba9a7d342a377c97991d370a7
+  metadata.gz: ff82f5ba11ed8afdfb840119c249c078f0b10024e746230eedf093169f63ae55
+  data.tar.gz: 0fe062fa3b73f168aeddde5a3a81a936a24faaa7be1b99329f8707bf52d89fbe
 SHA512:
-  metadata.gz: 5f12512e1c10dbbe36db63aadfb221c84de40f5e944538b73fa3ebfd61839dbbe11d2906e2cc9c88dd67790b1d4060883805c5f61eeb1b21058a0f57e78732c7
-  data.tar.gz: 10db3c5f50a2572198fa526fe1de55507b29d97499aae0238d2e8f447aac7ca960ce5159f897e4ba3150d90f8ffde5872848873a5414eb48b641fc91628247dc
+  metadata.gz: 1b7f42edce36076b5d467b6eefafdd02c40f381e25b9b010f0a32074ca51baea1a20545acdcde6a59467eb7a9b9b4fd930600f15a1858dd7aa54907ed855d391
+  data.tar.gz: edf9c74ae0704914ed4012984ee8642294e097092123ef9c79521e985857068df615946d74b6b059c69dd0868683e6706db971ec393b6fca44f961bbd190b403

data/CHANGELOG.md

@@ -7,6 +7,36 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.35] - 2026-04-23
+
+### Added
+- **Unified Terminal tool**: merged the old `safe_shell` and `shell` tools into a single `terminal` tool with persistent PTY sessions — the agent can now keep a shell session alive across tool calls, send input to running prompts, poll long-running commands, and safely interrupt them (`Ctrl+C` / `Ctrl+D`). Replaces 1000+ lines of duplicated shell-handling logic with a cleaner, better-tested implementation.
+- **Access key authentication for server mode**: start the Web UI server with `--access-key <key>` (or `CLACKY_ACCESS_KEY` env var) to require a login before anyone can open sessions — safe to expose the Web UI over the network or to share a running instance
+- **Session debug download**: from the Web UI you can now download a full session bundle (messages, tool calls, config) as a zip for debugging or sharing — useful for bug reports and post-mortems
+- **Scheduler now saves session state**: scheduled/cron tasks now persist their session after each run, so you can inspect what the scheduled task actually did from the Web UI just like a normal session
+- **Web UI visual redesign**: substantial redesign of the sidebar, session list, settings panel, and theme — cleaner spacing, better contrast in both light and dark modes, smoother transitions
+- **Web UI & channel message interrupt**: you can now cancel an in-progress agent reply from the Web UI or from an IM channel (Feishu/WeCom/WeChat) mid-flight instead of waiting for it to finish
+- **Terminal tool UI tips**: the Web UI now surfaces helpful inline tips when the agent is running a terminal command (e.g. "waiting for input", "process still running"), making long-running commands easier to follow
+
+### Improved
+- **Smaller tool descriptions**: trimmed the system-prompt footprint of `terminal`, `browser`, and `todo_manager` tool descriptions by ~40% — fewer tokens burned on every API call, slightly faster startup, and meaningfully cheaper sessions over time
+- **Download fallback for skills & brand assets**: when the primary platform download host is unreachable (common in certain regions), the client now automatically falls back to a secondary URL — skill installs and brand asset fetches succeed in more network environments
+- **Session cost shows "N/A" for unknown-price models**: instead of displaying `$0.00` when a model's pricing isn't registered, sessions now show "N/A" so you can tell the difference between "free call" and "we don't know the cost"
+- **Faster, more accurate progress updates**: removed a delay in the progress spinner so the "Agent is thinking..." and tool-running indicators update immediately on state changes instead of a second later
+- **No Claude-specific skill auto-loading**: removed legacy logic that special-cased loading `.claude/` skills at startup — skill loading is now uniform regardless of provider, reducing surprise behavior and confusing "unknown skill" errors
+
+### Fixed
+- **`file://` links now render and open correctly** (C-5552, C-5553): file:// links are no longer stripped during streaming in the Web UI, and clicking them now opens the file via the backend (including proper foreground focus on WSL via `cmd.exe /c start`). Also fixes silent drop of `file://` links in the CLI.
+- **Idle `Ctrl+C` no longer crashes the CLI**: pressing Ctrl+C while the CLI is idle (no task running) now exits cleanly instead of raising an error
+- **Session pinned status persists correctly** (C-5556): pinning a session in the Web UI now survives server restarts and is correctly restored from disk
+- **Brand skill names follow language switch**: brand-supplied skill names in the Web UI sidebar now update immediately when you toggle the UI language (previously stuck in the initial language until reload)
+- **New sessions get the default model**: fixed a case where newly created sessions could end up on a different model than the configured default; the "lite UI" mode is no longer automatically forced either
+
+### More
+- Large refactor of the UI2 `LayoutManager` + new `OutputBuffer` for cleaner CLI output line handling
+- Agent progress-emission refactor for more consistent spinner/tool state reporting across Web, CLI, and channel UIs
+- Removed the `safe_shell_spec` and `shell_spec` suites; replaced with a single, comprehensive `terminal_spec` (500+ lines of coverage)
+
 ## [0.9.34] - 2026-04-21
 
 ### Added

data/lib/clacky/agent/cost_tracker.rb

@@ -41,7 +41,7 @@ module Clacky
         token_data = collect_iteration_tokens(usage, iteration_cost)
 
         # Update session bar cost in real-time (don't wait for agent.run to finish)
-        @ui&.update_sessionbar(cost: @total_cost)
+        @ui&.update_sessionbar(cost: @total_cost, cost_source: @cost_source)
 
         # Track cache usage statistics (global)
         @cache_stats[:total_requests] += 1

data/lib/clacky/agent/llm_caller.rb

@@ -35,12 +35,20 @@ module Clacky
       #                user experiences no extra delay.
       #
       # @return [Hash] API response with :content, :tool_calls, :usage, etc.
+      # NOTE on progress lifecycle:
+      #   call_llm intentionally does NOT start or stop the progress indicator.
+      #   Ownership lives with the caller (Agent#think for normal/compression
+      #   paths, Agent#trigger_idle_compression for idle compression). This
+      #   avoids nested active/done pairs clobbering each other — a bug that
+      #   silently dropped the idle-compression summary line.
+      #
+      #   Inside call_llm we only *update in place* during retries, so the
+      #   already-live progress slot shows meaningful transient status
+      #   ("Network failed… attempt 2/10", etc.).
       private def call_llm
         # Transition :fallback_active → :probing if cooling-off has expired.
         @config.maybe_start_probing
 
-        @ui&.show_progress
-
         tools_to_send = @tool_registry.all_definitions
 
         max_retries = 10
@@ -68,7 +76,6 @@ module Clacky
           handle_probe_success if @config.probing?
 
         rescue Faraday::ConnectionFailed, Faraday::TimeoutError, Faraday::SSLError, Errno::ECONNREFUSED, Errno::ETIMEDOUT => e
-          @ui&.show_progress(phase: "done")
           retries += 1
 
           # Probing failure: primary still down — renew cooling-off and retry with fallback.
@@ -90,13 +97,12 @@ module Clacky
             sleep retry_delay
             retry
           else
-            @ui&.show_progress(phase: "done")
-            # Don't show_error here — let the outer rescue block handle it to avoid duplicates
+            # Don't show_error here — let the outer rescue block handle it to avoid duplicates.
+            # Progress cleanup is the caller's responsibility (via its own ensure block).
             raise AgentError, "[LLM] Network connection failed after #{max_retries} retries: #{e.message}"
           end
 
         rescue RetryableError => e
-          @ui&.show_progress(phase: "done")
           retries += 1
 
           # Probing failure: primary still down — renew cooling-off and retry with fallback.
@@ -127,12 +133,10 @@ module Clacky
           sleep retry_delay
           retry
         else
-          @ui&.show_progress(phase: "done")
-          # Don't show_error here — let the outer rescue block handle it to avoid duplicates
+          # Don't show_error here — let the outer rescue block handle it to avoid duplicates.
+          # Progress cleanup is the caller's responsibility (via its own ensure block).
           raise AgentError, "[LLM] Service unavailable after #{current_max} retries"
         end
-        ensure
-          @ui&.show_progress(phase: "done")
         end
 
         # Track cost and collect token usage data.

data/lib/clacky/agent/memory_updater.rb

@@ -130,7 +130,7 @@ module Clacky
           For each qualifying topic:
             a. If a matching file exists → read it with `file_reader(path: "~/.clacky/memories/<filename>")`, then write an updated version (merge new + old, drop stale)
             b. If no matching file → create a new one at `~/.clacky/memories/<new-filename>.md`
-          Use the `write` tool to save each file. Do NOT use `safe_shell` or `file_reader` to list the directory.
+          Use the `write` tool to save each file. Do NOT use `terminal` or `file_reader` to list the directory.
 
           ## Hard constraints (CRITICAL)
           - Each file MUST stay under 4000 characters of content (after the frontmatter)

data/lib/clacky/agent/session_serializer.rb

@@ -10,6 +10,7 @@ module Clacky
       def restore_session(session_data)
         @session_id = session_data[:session_id]
         @name = session_data[:name] || ""
+        @pinned = session_data[:pinned] || false
         @history = MessageHistory.new(session_data[:messages] || [])
         @todos = session_data[:todos] || []  # Restore todos from session
         @iterations = session_data.dig(:stats, :total_iterations) || 0
@@ -77,6 +78,7 @@ module Clacky
         {
           session_id: @session_id,
           name: @name,
+          pinned: @pinned,
           created_at: @created_at,
           updated_at: Time.now.iso8601,
           working_dir: @working_dir,

data/lib/clacky/agent/skill_manager.rb

@@ -456,7 +456,7 @@ module Clacky
         # the real cumulative spend across all subagents
         subagent_cost = result[:total_cost_usd] || 0.0
         @total_cost += subagent_cost
-        @ui&.update_sessionbar(cost: @total_cost)
+        @ui&.update_sessionbar(cost: @total_cost, cost_source: @cost_source)
 
         # Log completion
         @ui&.show_info("Subagent completed: #{result[:iterations]} iterations, $#{subagent_cost.round(4)} (total: $#{@total_cost.round(4)})")

data/lib/clacky/agent/tool_executor.rb

@@ -21,7 +21,7 @@ module Clacky
           #   confirm_all  → human present, truly wait for user input
           true
         when :confirm_safes
-          # Use SafeShell integration for safety check
+          # Use Security module to check auto-execution safety
           is_safe_operation?(tool_name, tool_params)
         else
           false
@@ -33,13 +33,14 @@ module Clacky
       # @param tool_params [Hash, String] Tool parameters
       # @return [Boolean] true if safe operation
       def is_safe_operation?(tool_name, tool_params = {})
-        # For shell commands, use SafeShell to check safety
-        if tool_name.to_s.downcase == 'shell' || tool_name.to_s.downcase == 'safe_shell'
+        # For terminal commands, defer to Security layer for the verdict.
+        if tool_name.to_s.downcase == 'terminal'
           params = tool_params.is_a?(String) ? JSON.parse(tool_params) : tool_params
           command = params[:command] || params['command']
-          return false unless command
+          # No command = session_id continuation / kill / action → safe by default.
+          return true unless command
 
-          return Tools::SafeShell.command_safe_for_auto_execution?(command)
+          return Clacky::Tools::Security.command_safe_for_auto_execution?(command)
         end
 
         if tool_name.to_s.downcase == 'edit' || tool_name.to_s.downcase == 'write'
@@ -140,10 +141,10 @@ module Clacky
             else
               "Write(#{filename}) - create new"
             end
-          when "shell", "safe_shell"
+          when "terminal"
             cmd = args[:command] || ''
             display_cmd = cmd.length > 30 ? "#{cmd[0..27]}..." : cmd
-            "#{call[:name]}(\"#{display_cmd}\")"
+            "terminal(\"#{display_cmd}\")"
           else
             "Allow #{call[:name]}"
           end
@@ -241,7 +242,7 @@ module Clacky
       # @return [Boolean] true if tool is potentially slow
       private def potentially_slow_tool?(tool_name, args)
         case tool_name.to_s.downcase
-        when 'shell', 'safe_shell'
+        when 'terminal'
           # Check if the command is a slow command
           command = args[:command] || args['command']
           return false unless command
@@ -257,24 +258,20 @@ module Clacky
             /make\s+(test|build)/,
             /pytest/,
             /jest/,
-            /sleep\s+\d+/  # sleep command with duration
+            /sleep\s+\d+/
           ]
 
           slow_patterns.any? { |pattern| command.match?(pattern) }
         when 'web_fetch', 'web_search'
-          true  # Network operations can be slow
+          true
         else
-          false  # Most file operations are fast
+          false
         end
       end
 
-      # Build progress message for tool execution
-      # @param tool_name [String] Name of the tool
-      # @param args [Hash] Tool arguments
-      # @return [String] Progress message
       private def build_tool_progress_message(tool_name, args)
         case tool_name.to_s.downcase
-        when 'shell', 'safe_shell'
+        when 'terminal'
           "Running command"
         when 'web_fetch'
           "Fetching web page"

data/lib/clacky/agent/tool_registry.rb

@@ -11,9 +11,6 @@ module Clacky
     end
 
     def get(name)
-      # Handle shell alias to safe_shell for backward compatibility
-      name = 'safe_shell' if name == 'shell' && @tools.key?('safe_shell') && !@tools.key?('shell')
-      
       @tools[name] || raise(Clacky::ToolCallError, "Tool not found: #{name}")
     end
 

data/lib/clacky/agent.rb

@@ -43,6 +43,7 @@ module Clacky
     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,
                 :status, :error, :updated_at, :source
+    attr_accessor :pinned
 
     def permission_mode
       @config&.permission_mode&.to_s || ""
@@ -57,6 +58,7 @@ module Clacky
       @hooks = HookManager.new
       @session_id = session_id
       @name = ""
+      @pinned = false
       @history = MessageHistory.new
       @todos = []  # Store todos in memory
       @iterations = 0
@@ -188,6 +190,14 @@ module Clacky
     end
 
     def run(user_input, files: [])
+      # Show the "thinking" indicator as early as possible so the user gets
+      # immediate feedback after sending a message. Without this the UI stays
+      # silent during synchronous setup work (system prompt assembly, file
+      # parsing, history compression checks) before the first LLM call. The
+      # subsequent `think` call will re-emit show_progress, which is an
+      # idempotent update on the same progress UI element.
+      @ui&.show_progress
+
       # Start new task for Time Machine
       task_id = start_new_task
 
@@ -477,6 +487,11 @@ module Clacky
         # Always clean up memory update messages, even if interrupted or error occurred
         cleanup_memory_messages
 
+        # Safety net: ensure any lingering progress spinner is stopped.
+        # Normal paths close their own spinners; this guards against exceptions
+        # raised between a progress slot's active/done pair.
+        @ui&.show_progress(phase: "done")
+
         # Shred any decrypted-script tmpdirs created during this run for encrypted brand skills.
         # This covers the inline-injection path; the subagent path shreds immediately after
         # subagent.run returns (see execute_skill_with_subagent).
@@ -491,6 +506,12 @@ module Clacky
         raise AgentError, "API key is not configured"
       end
 
+      # Ensure a thinking progress indicator is live for the duration of this
+      # LLM turn. This is idempotent — if `run` already started one at task
+      # entry (or a previous iteration left one running), the UI recognizes
+      # the bare reentry and preserves the existing spinner.
+      @ui&.show_progress
+
       # Check if compression is needed
       compression_context = compress_messages_if_needed(force: false)
 
@@ -500,6 +521,14 @@ module Clacky
         @ui&.show_info(
           "Message history compression starting (~#{compression_context[:original_token_count]} tokens, #{compression_context[:original_message_count]} messages) - Level #{compression_context[:compression_level]}"
         )
+        # Take over the progress slot with a compression-specific message.
+        # handle_compression_response will close it with the summary line on
+        # success; on failure the outer ensure below finalizes it.
+        @ui&.show_progress(
+          "Compressing message history...",
+          progress_type: "idle_compress",
+          phase: "active"
+        )
         compression_message = compression_context[:compression_message]
         @history.append(compression_message)
         compression_handled = false
@@ -518,13 +547,24 @@ module Clacky
             # (with the user's new message as the last entry), producing consecutive user messages
             # that confuse the LLM into echoing compression instructions.
             @compression_level -= 1
+            # Close the compression progress slot so the spinner does not linger.
+            @ui&.show_progress(phase: "done")
           end
         end
         return nil
       end
 
-      # Normal LLM call
-      response = call_llm
+      # Normal LLM call. call_llm no longer manages the progress lifecycle;
+      # we keep the spinner live across the call and finalize it here so the
+      # UI transitions cleanly to the assistant message that follows.
+      response = nil
+      begin
+        response = call_llm
+      rescue
+        # Ensure the spinner is stopped on any error path before it bubbles up.
+        @ui&.show_progress(phase: "done")
+        raise
+      end
 
       # Handle truncated responses (when max_tokens limit is reached)
       if response[:finish_reason] == "length"
@@ -533,6 +573,7 @@ module Clacky
 
         if @task_truncation_count >= 3
           # Too many truncations - task is too complex
+          @ui&.show_progress(phase: "done")
           @ui&.show_error("Response truncated multiple times. Task is too complex.")
 
           # Create a response that tells the user to break down the task
@@ -578,6 +619,9 @@ module Clacky
           truncated: true
         })
 
+        # Close the current spinner so the warning appears cleanly;
+        # the recursive think() call below will reopen a new one.
+        @ui&.show_progress(phase: "done")
         @ui&.show_warning("Response truncated (#{@task_truncation_count}/3). Retrying with smaller steps...")
 
         # Recursively retry
@@ -600,6 +644,11 @@ module Clacky
       msg[:reasoning_content] = response[:reasoning_content] if response[:reasoning_content]
       @history.append(msg)
 
+      # Close the thinking spinner before returning. The caller (run loop)
+      # is about to render the assistant message and/or tool invocations,
+      # which should appear after the spinner disappears.
+      @ui&.show_progress(phase: "done")
+
       response
     end
 
@@ -686,46 +735,24 @@ module Clacky
             args[:agent] = self
           end
 
-          # For safe_shell, skip safety check if user has already confirmed
-          if call[:name] == "safe_shell" || call[:name] == "shell"
-            args[:skip_safety_check] = true
-          end
-
           # Inject working_dir so tools don't rely on Dir.chdir global state
           args[:working_dir] = @working_dir if @working_dir
 
-          # Automatic progress display after 2 seconds for any tool execution
+          # Show progress immediately for every tool execution so the user
+          # always knows the agent is working. (Previously we deferred this by
+          # 2 seconds to avoid flicker in the legacy CLI TUI; that trade-off is
+          # no longer desirable now that progress is a first-class UI state in
+          # the Web UI and structured JSON UIs.)
           progress_shown = false
-          progress_timer = nil
-
           if @ui
             progress_message = build_tool_progress_message(call[:name], args)
-
-            # For shell/safe_shell: inject on_output callback for real-time stdout streaming.
-            # The callback fires immediately on each read_nonblock chunk — no polling delay.
-            if (call[:name] == "shell" || call[:name] == "safe_shell") &&
-               @ui.respond_to?(:show_tool_stdout)
-              args[:on_output] = ->(stream, data) {
-                @ui.show_tool_stdout([data]) if stream == :stdout
-              }
-            end
-
-            progress_timer = Thread.new do
-              sleep 2
-              @ui.show_progress(progress_message, prefix_newline: false)
-              progress_shown = true
-              # Streaming is handled by on_output callback — no polling loop needed here
-            end
+            @ui.show_progress(progress_message, prefix_newline: false)
+            progress_shown = true
           end
 
           begin
             result = tool.execute(**args)
           ensure
-            # Cancel timer and clear progress if shown
-            if progress_timer
-              progress_timer.kill
-              progress_timer.join
-            end
             @ui&.show_progress(phase: "done") if progress_shown
           end
 
@@ -927,7 +954,7 @@ module Clacky
     end
 
     private def register_builtin_tools
-      @tool_registry.register(Tools::SafeShell.new)
+      @tool_registry.register(Tools::Terminal.new)
       @tool_registry.register(Tools::FileReader.new)
       @tool_registry.register(Tools::Write.new)
       @tool_registry.register(Tools::Edit.new)
@@ -936,7 +963,6 @@ module Clacky
       @tool_registry.register(Tools::WebSearch.new)
       @tool_registry.register(Tools::WebFetch.new)
       @tool_registry.register(Tools::TodoManager.new)
-      # @tool_registry.register(Tools::RunProject.new) # temporarily disabled
       @tool_registry.register(Tools::RequestUserFeedback.new)
       @tool_registry.register(Tools::InvokeSkill.new)
       @tool_registry.register(Tools::UndoTask.new)
@@ -1250,13 +1276,13 @@ module Clacky
     #   [Download report](file:///path/to/file.pdf)
     #   ![chart](file:///path/to/chart.png)
     #
-    # Returns { text: String, files: Array<{name:, path:, inline:}> }
-    # File links are stripped from the returned text.
+    # Returns { text: String (original content, unmodified),
+    #           files: Array<{name:, path:, inline:}> }
     private def parse_file_links(content)
       return { text: content, files: [] } if content.nil? || content.empty?
 
       files = []
-      text = content.gsub(/(!?)\[([^\]]*)\]\(file:\/\/([^)]+)\)/) do
+      content.scan(/(!?)\[([^\]]*)\]\(file:\/\/([^)]+)\)/) do
         inline = $1 == "!"
         # URL-decode percent-encoded characters (e.g. Chinese filenames encoded by AI)
         raw_path = CGI.unescape($3)
@@ -1264,9 +1290,8 @@ module Clacky
         path   = File.expand_path(raw_path)
         Clacky::Logger.info("[parse_file_links] raw=#{$3.inspect} expanded=#{path.inspect} exist=#{File.exist?(path)}")
         files << { name: name, path: path, inline: inline }
-        ""
       end
-      { text: text.strip, files: files }
+      { text: content, files: files }
     end
 
     # Emit assistant message to UI, parsing any embedded file:// links first.

data/lib/clacky/agent_config.rb

@@ -238,7 +238,11 @@ module Clacky
       # The injected lite model is runtime-only (not persisted to config.yml)
       inject_provider_lite_model(models)
 
-      new(models: models)
+      # Find the index of the model marked as "default" (type: default)
+      # Fall back to 0 if no model has type: default
+      default_index = models.find_index { |m| m["type"] == "default" } || 0
+
+      new(models: models, current_model_index: default_index)
     end
 
     # Auto-inject a lite model entry if the default model's provider supports one

data/lib/clacky/brand_config.rb

@@ -533,9 +533,11 @@ module Clacky
       dest_dir = File.join(brand_skills_dir, slug)
       FileUtils.mkdir_p(dest_dir)
 
-      # Download the zip file to a temp path
+      # Download the zip file to a temp path via PlatformHttpClient so the
+      # primary → fallback host failover applies uniformly to every download.
       tmp_zip = File.join(brand_skills_dir, "#{slug}.zip")
-      download_file(url, tmp_zip)
+      dl = platform_client.download_file(url, tmp_zip)
+      raise dl[:error].to_s unless dl[:success]
 
       # Extract into dest_dir (overwrite existing files).
       # Auto-detect whether the zip has a single root folder to strip.
@@ -1072,32 +1074,14 @@ module Clacky
     end
 
     # Download a remote URL to a local file path.
+    #
+    # Deprecated: this method now delegates to
+    # Clacky::PlatformHttpClient#download_file so that every brand-skill download
+    # benefits from primary → fallback host failover. Kept as a thin wrapper
+    # so existing callers / tests that stub it continue to work.
     private def download_file(url, dest, max_redirects: 10)
-      require "net/http"
-      require "uri"
-
-      uri = URI.parse(url)
-      max_redirects.times do
-        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
-                        open_timeout: 15, read_timeout: 60) do |http|
-          http.request_get(uri.request_uri) do |resp|
-            case resp.code.to_i
-            when 200
-              File.open(dest, "wb") { |f| resp.read_body { |chunk| f.write(chunk) } }
-              return
-            when 301, 302, 303, 307, 308
-              location = resp["location"]
-              raise "Redirect with no Location header" if location.nil? || location.empty?
-
-              uri = URI.parse(location)
-              break  # break out of Net::HTTP.start, re-enter loop with new uri
-            else
-              raise "HTTP #{resp.code}"
-            end
-          end
-        end
-      end
-      raise "Too many redirects"
+      result = platform_client.download_file(url, dest)
+      raise result[:error].to_s unless result[:success]
     end
 
     # Persist installed skill metadata to brand_skills.json.

data/lib/clacky/cli.rb

@@ -663,6 +663,18 @@ module Clacky
 
         # Set up interrupt handler
         ui_controller.on_interrupt do |input_was_empty:|
+          # Priority 1: if idle compression work is actually in flight,
+          # Ctrl+C should stop compression — not exit the program. The
+          # compress thread rolls back history cleanly on AgentInterrupted.
+          if idle_timer.compressing?
+            idle_timer.cancel
+            ui_controller.show_progress(phase: "done")
+            ui_controller.set_idle_status
+            ui_controller.show_warning("Compression interrupted by user")
+            ui_controller.clear_input
+            next
+          end
+
           if (not current_task_thread&.alive?) && input_was_empty
             # Save final session state before exit
             if session_manager && agent.total_tasks > 0
@@ -822,6 +834,30 @@ module Clacky
     option :brand_test, type: :boolean, default: false,
            desc: "Enable brand test mode: mock license activation without calling remote API"
     def server
+      # ── Security gate ──────────────────────────────────────────────────────
+      # Binding to 0.0.0.0 exposes the server to the public network.
+      # Refuse to start unless CLACKY_ACCESS_KEY env var is set.
+      if options[:host] == "0.0.0.0" && ENV.fetch("CLACKY_ACCESS_KEY", "").strip.empty?
+        puts <<~MSG
+          ╔══════════════════════════════════════════════════════════════╗
+          ║  ⚠️  Security Warning: Refusing to start                      ║
+          ╠══════════════════════════════════════════════════════════════╣
+          ║                                                              ║
+          ║  Binding to 0.0.0.0 exposes Clacky to the public network.    ║
+          ║  You must set CLACKY_ACCESS_KEY before starting the server.  ║
+          ║                                                              ║
+          ║  Generate a secure key:                                      ║
+          ║    openssl rand -hex 32                                      ║
+          ║                                                              ║
+          ║  Then export it:                                             ║
+          ║    export CLACKY_ACCESS_KEY=<your-generated-key>             ║
+          ║                                                              ║
+          ╚══════════════════════════════════════════════════════════════╝
+        MSG
+        exit(1)
+      end
+      # ─────────────────────────────────────────────────────────────────────
+
       if ENV["CLACKY_WORKER"] == "1"
         # ── Worker mode ───────────────────────────────────────────────────────
         # Spawned by Master. Inherit the listen socket from the file descriptor

data/lib/clacky/default_skills/channel-setup/SKILL.md

@@ -92,7 +92,7 @@ Run the setup script (full path is available in the supporting files list above)
 ```bash
 ruby "SKILL_DIR/feishu_setup.rb"
 ```
-**Important**: call `safe_shell` with `timeout: 180` — the script may wait up to 90s for a WebSocket connection in Phase 4.
+**Important**: call `terminal` with `timeout: 180` — the script may wait up to 90s for a WebSocket connection in Phase 4.
 
 **If exit code is 0:**
 - The script completed successfully.

data/lib/clacky/default_skills/deploy/scripts/rails_deploy.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Ensure all output is flushed immediately so users see live progress
-# even when the script is run inside a subprocess (safe_shell / Open3).
+# even when the script is run inside a subprocess (terminal / Open3).
 $stdout.sync = true
 $stderr.sync = true
 

data/lib/clacky/default_skills/new/SKILL.md

@@ -100,7 +100,7 @@ Do you want to reuse this binding? (y/n)
 
 #### 3.2 Run the cloud project init script
 Use the `cloud_project_init.sh` script from Supporting Files.
-Run it with safe_shell from the project directory (no arguments needed — it auto-reads `~/.clacky/clacky_cloud.yml`):
+Run it with `terminal` from the project directory (no arguments needed — it auto-reads `~/.clacky/clacky_cloud.yml`):
 
 ```bash
 bash <absolute_path_to_cloud_project_init.sh>

data/lib/clacky/default_skills/product-help/SKILL.md

@@ -7,7 +7,7 @@ auto_summarize: true
 forbidden_tools:
   - write
   - edit
-  - safe_shell
+  - terminal
   - web_search
 ---
 

data/lib/clacky/default_skills/recall-memory/SKILL.md

@@ -45,7 +45,7 @@ file_reader(path: "~/.clacky/memories/<filename>")
 
 2. Touch the file to update its mtime (LRU signal — keeps it surfaced in future recalls):
 ```
-safe_shell(command: "touch ~/.clacky/memories/<filename>")
+terminal(command: "touch ~/.clacky/memories/<filename>")
 ```
 
 Return ONLY the memory content, structured as:

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

@@ -62,7 +62,7 @@ Fast, opinionated skill creation without user interaction. This mode is used by
 ```
 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.",
+  task: "Create a skill to extract and summarize content from URLs. The skill should: 1) fetch the URL using terminal 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"
 )