openclacky 0.9.34 → 0.9.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52f436f4aa95f2360172d33a3f6703b9106f9568d1c805fbc26248e9b483834c
-  data.tar.gz: 42469a3ba3c357420b036fc4d877875e030e4dfba9a7d342a377c97991d370a7
+  metadata.gz: 8a7f74cba226bc2332676ed9f0a72c27f3fb6b45bafacd60198f7ec9b59a84c7
+  data.tar.gz: 7396d2258a38e203a5ffe217f0409fb101487bdb74dad8f224649a09b8adb775
 SHA512:
-  metadata.gz: 5f12512e1c10dbbe36db63aadfb221c84de40f5e944538b73fa3ebfd61839dbbe11d2906e2cc9c88dd67790b1d4060883805c5f61eeb1b21058a0f57e78732c7
-  data.tar.gz: 10db3c5f50a2572198fa526fe1de55507b29d97499aae0238d2e8f447aac7ca960ce5159f897e4ba3150d90f8ffde5872848873a5414eb48b641fc91628247dc
+  metadata.gz: 7f10c234d4a22d825e3623bff7e0a0faf55af4cea34dc15a939fbde3e6e3792bf1a11cd97d68e0c6890dd37c011814019cfed7dea70c724fcb2fc11b49cff15a
+  data.tar.gz: 12dcd062214b42191f33e4b2e09ec62f24cb9f91206451ff23861672a2cc8b680d89e5498cf0da6c53b74d4da2933bd53863666cee608539edb398f016226df5

data/CHANGELOG.md

@@ -7,6 +7,48 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.36] - 2026-04-24
+
+### Fixed
+- **Session deletion now works correctly**: fixed disk-based session deletion that was failing with proper error handling in the Web UI (C-9d1ea93)
+- **Model switching improved**: better model ID validation and normalization when switching models in Web UI — handles various ID formats correctly (C-b61e22e)
+- **Terminal tool word wrapping**: fixed terminal output word wrapping issues that could break long command outputs (C-5989d02)
+- **Heartbeat mechanism stability**: improved async heartbeat logic in server mode for more reliable connection status tracking (C-5989d02)
+
+### Improved
+- **UI polish**: removed session topbar clutter and added empty state messages for better first-time user experience (C-003d613)
+- **Cleaner logging**: reduced noisy debug logs in skill manager for quieter operation (C-c27bbec)
+
+## [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

@@ -68,15 +68,27 @@ module Clacky
         all_skills = all_skills.reject(&:invalid?)
         auto_invocable = all_skills.select(&:model_invocation_allowed?)
 
-        # Enforce system prompt injection limit to control token usage
+        # Enforce system prompt injection limit to control token usage.
+        # Warn only when the set of dropped skills *changes* — this message
+        # is otherwise emitted once per agent turn (build_skill_context is
+        # called during every system prompt assembly) and floods the log.
         if auto_invocable.size > MAX_CONTEXT_SKILLS
-          dropped = auto_invocable.size - MAX_CONTEXT_SKILLS
-          Clacky::Logger.warn(
-            "Skill context limit: #{auto_invocable.size} auto-invocable skills found, " \
-            "only injecting first #{MAX_CONTEXT_SKILLS} (#{dropped} dropped). " \
-            "Remove unused skills to restore full visibility."
-          )
-          auto_invocable = auto_invocable.first(MAX_CONTEXT_SKILLS)
+          kept    = auto_invocable.first(MAX_CONTEXT_SKILLS)
+          dropped = auto_invocable.drop(MAX_CONTEXT_SKILLS)
+          dropped_names = dropped.map(&:identifier)
+          signature = dropped_names.sort.join(",")
+
+          if @skill_limit_warned_signature != signature
+            @skill_limit_warned_signature = signature
+            Clacky::Logger.warn(
+              "Skill context limit: #{auto_invocable.size} auto-invocable skills found, " \
+              "only injecting first #{MAX_CONTEXT_SKILLS} " \
+              "(#{dropped.size} dropped — will NOT be auto-discovered by the agent: " \
+              "#{dropped_names.join(", ")}). " \
+              "Remove unused skills to restore full visibility."
+            )
+          end
+          auto_invocable = kept
         end
 
         return "" if auto_invocable.empty?
@@ -456,7 +468,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
@@ -129,14 +131,21 @@ module Clacky
       @hooks.add(event, &block)
     end
 
-    # Switch to a different model by index
-    # @param index [Integer] Model index (0-based)
+    # Switch this session to a different model, identified by its stable
+    # runtime id. Ids survive list reorders, additions, and field edits,
+    # which is why we no longer expose an index-based API.
+    # @param id [String] Model id (see AgentConfig#parse_models)
     # @return [Boolean] true if switched successfully, false otherwise
-    def switch_model(index)
-      # Switch config to the model by index
-      return false unless @config.switch_model(index)
-      
-      # Re-create client for new model
+    def switch_model_by_id(id)
+      return false unless @config.switch_model_by_id(id)
+
+      rebuild_client_for_current_model!
+      true
+    end
+
+    # Rebuild the underlying Client (and dependent components) to pick up
+    # credentials/model name from the currently-selected model in @config.
+    private def rebuild_client_for_current_model!
       @client = Clacky::Client.new(
         @config.api_key,
         base_url: @config.base_url,
@@ -145,11 +154,9 @@ module Clacky
       )
       # Update message compressor with new client and model
       @message_compressor = MessageCompressor.new(@client, model: current_model)
-      
+
       # Inject a new session context to notify the AI of the model switch
       inject_session_context
-      
-      true
     end
 
     # Change the working directory for this session
@@ -188,6 +195,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 +492,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 +511,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 +526,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 +552,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 +578,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 +624,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 +649,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 +740,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 +959,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 +968,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)
@@ -961,16 +992,16 @@ module Clacky
         if model == "lite"
           # Special keyword: use lite model if available, otherwise fall back to default
           lite_model = subagent_config.lite_model
-          if lite_model
-            model_index = subagent_config.models.index(lite_model)
-            subagent_config.switch_model(model_index) if model_index
+          if lite_model && lite_model["id"]
+            subagent_config.switch_model_by_id(lite_model["id"])
           end
           # If no lite model, just use current (default) model
         else
-          # Regular model name lookup
-          model_index = subagent_config.model_names.index(model)
-          if model_index
-            subagent_config.switch_model(model_index)
+          # Regular model name lookup — find the first model with a matching
+          # name and switch by its stable id.
+          target = subagent_config.models.find { |m| m["model"] == model }
+          if target && target["id"]
+            subagent_config.switch_model_by_id(target["id"])
           else
             raise AgentError, "Model '#{model}' not found in config. Available models: #{subagent_config.model_names.join(', ')}"
           end
@@ -1250,13 +1281,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 +1295,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.