openclacky 0.9.38 → 1.0.0.beta.2

data/lib/clacky/agent/time_machine.rb

@@ -93,13 +93,22 @@ module Clacky
       # Filter messages to only show tasks up to active_task_id.
       # This hides "future" messages when user has undone.
       # Returns API-ready array (strips internal fields + handles orphaned tool_calls).
+      # @param force_reasoning_content_pad [Boolean] forwarded to MessageHistory,
+      #   enables one-shot pad-and-retry for thinking-mode providers that
+      #   require reasoning_content on every assistant message.
       # Made public for testing
-      def active_messages
-        return @history.to_api if @active_task_id == @current_task_id
+      def active_messages(force_reasoning_content_pad: false)
+        if @active_task_id == @current_task_id
+          return @history.to_api(force_reasoning_content_pad: force_reasoning_content_pad)
+        end
 
-        @history.for_task(@active_task_id).map do |msg|
+        stripped = @history.for_task(@active_task_id).map do |msg|
           msg.reject { |k, _| MessageHistory::INTERNAL_FIELDS.include?(k) }
         end
+        # Apply the same reasoning_content padding rule used by to_api so
+        # Time Machine replays satisfy thinking-mode providers after a
+        # 400 retry.
+        MessageHistory.pad_reasoning_content_if_needed(stripped, force: force_reasoning_content_pad)
       end
 
       # Undo to parent task

data/lib/clacky/agent/tool_executor.rb

@@ -10,9 +10,6 @@ module Clacky
       # @param tool_params [Hash, String] Tool parameters
       # @return [Boolean] true if should auto-execute
       def should_auto_execute?(tool_name, tool_params = {})
-        # During memory update phase, always auto-execute (no user confirmation needed)
-        return true if @memory_updating
-
         case @config.permission_mode
         when :auto_approve, :confirm_all
           # Both modes auto-execute all file/shell tools without confirmation.

data/lib/clacky/agent.rb

@@ -265,9 +265,15 @@ module Clacky
         path = f[:path] || f["path"]
         name = f[:name] || f["name"]
         next f unless path && File.exist?(path.to_s)
+        # Preserve the downgrade_reason tag across the remap (process_path
+        # returns a fresh FileRef that doesn't know about it). Without this,
+        # the file_prompt builder can't emit the "not supported by model" /
+        # "too large" note for downgraded images.
+        downgrade_reason = f[:downgrade_reason] || f["downgrade_reason"]
         ref = Utils::FileProcessor.process_path(path, name: name)
         { name: ref.name, type: ref.type.to_s, path: ref.original_path,
-          preview_path: ref.preview_path, parse_error: ref.parse_error, parser_path: ref.parser_path }
+          preview_path: ref.preview_path, parse_error: ref.parse_error, parser_path: ref.parser_path,
+          downgrade_reason: downgrade_reason }
       end
 
       # Build display_files for replay: lightweight metadata so the UI can reconstruct
@@ -295,13 +301,14 @@ module Clacky
 
       unless all_meta_files.empty?
         file_prompt = all_meta_files.filter_map do |f|
-          name         = f[:name]         || f["name"]
-          type         = f[:type]         || f["type"]
-          path         = f[:path]         || f["path"]
-          preview_path = f[:preview_path] || f["preview_path"]
-          size_bytes   = f[:size_bytes]   || f["size_bytes"]
-          parse_error  = f[:parse_error]  || f["parse_error"]
-          parser_path  = f[:parser_path]  || f["parser_path"]
+          name             = f[:name]             || f["name"]
+          type             = f[:type]             || f["type"]
+          path             = f[:path]             || f["path"]
+          preview_path     = f[:preview_path]     || f["preview_path"]
+          size_bytes       = f[:size_bytes]       || f["size_bytes"]
+          parse_error      = f[:parse_error]      || f["parse_error"]
+          parser_path      = f[:parser_path]      || f["parser_path"]
+          downgrade_reason = f[:downgrade_reason] || f["downgrade_reason"]
 
           next unless name
 
@@ -310,6 +317,13 @@ module Clacky
           lines << "Original: #{path}" if path
           lines << "Preview (Markdown): #{preview_path}" if preview_path
 
+          # Inline note explaining why an image was *not* sent as vision
+          # content. Colocated with the file info (not in system prompt) so
+          # it reflects the exact reason for *this* upload under *this*
+          # model — switching models later won't leave stale warnings.
+          note = downgrade_note_for(downgrade_reason)
+          lines << "Note: #{note}" if note
+
           # Parser failed — instruct LLM to fix and re-run
           if preview_path.nil? && parse_error
             lines << "Parse failed: #{parse_error}"
@@ -362,10 +376,7 @@ module Clacky
 
           # Check if done (no more tool calls needed)
           if response[:finish_reason] == "stop" || response[:tool_calls].nil? || response[:tool_calls].empty?
-            # During memory update phase, show LLM response as info (not a chat bubble)
-            if @memory_updating && response[:content] && !response[:content].empty?
-              @ui&.show_info(response[:content].strip)
-            elsif response[:content] && !response[:content].empty?
+            if response[:content] && !response[:content].empty?
               emit_assistant_message(response[:content])
             end
 
@@ -382,15 +393,11 @@ module Clacky
               end
             end
 
-            # Inject memory update prompt and let the loop handle it naturally
-            next if inject_memory_prompt!
-
             break
           end
 
           # Show assistant message if there's content before tool calls
-          # During memory update phase, suppress text output (only tool calls matter)
-          if response[:content] && !response[:content].empty? && !@memory_updating
+          if response[:content] && !response[:content].empty?
             emit_assistant_message(response[:content])
           end
 
@@ -453,6 +460,17 @@ module Clacky
           run_skill_evolution_hooks
         end
 
+        # Run long-term memory update as a forked subagent BEFORE we print
+        # show_complete. Running it as a subagent (rather than inline in
+        # the main loop) gives us correct visual ordering structurally:
+        # the subagent blocks until done, its progress spinner finishes,
+        # and only then [OK] Task Complete is printed. No cleanup dance,
+        # no cross-method progress handle holding.
+        # Skip on interrupt / feedback / subagent (self-guarded inside too).
+        unless @is_subagent || task_interrupted || awaiting_user_feedback
+          run_memory_update_subagent
+        end
+
         if @is_subagent
           # Parent agent (skill_manager) prints the completion summary; skip here.
         else
@@ -489,9 +507,6 @@ module Clacky
         result = build_result(:error, error: e.message)  # rubocop:disable Lint/UselessAssignment
         raise
       ensure
-        # 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.
@@ -501,6 +516,10 @@ module Clacky
         # This covers the inline-injection path; the subagent path shreds immediately after
         # subagent.run returns (see execute_skill_with_subagent).
         shred_script_tmpdirs
+
+        # Fire-and-forget telemetry after every agent run.
+        # Tracks daily active users (distinct devices per day) and task volume.
+        Clacky::Telemetry.task!
       end
     end
 
@@ -526,21 +545,33 @@ 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
+
+        # Open a dedicated quiet-style handle for the compression work.
+        # This sits on top of the outer thinking progress (if any); Plan B
+        # semantics detach the outer spinner until we finish here. On any
+        # exception the ensure block in with_progress guarantees the
+        # handle is released — no more orphan gray ticker colliding with
+        # a yellow ticker (the original flicker bug).
+        #
+        # NOTE: safe-navigation (+&.+) with blocks silently skips the
+        # block when the receiver is nil. We need the compression work to
+        # run even when @ui is nil (e.g. in tests), so branch explicitly.
         begin
-          response = call_llm
-          handle_compression_response(response, compression_context)
-          compression_handled = true
+          if @ui
+            @ui.with_progress(message: "Compressing message history...", style: :quiet) do |handle|
+              response = call_llm
+              handle_compression_response(response, compression_context, progress: handle)
+              compression_handled = true
+            end
+          else
+            response = call_llm
+            handle_compression_response(response, compression_context)
+            compression_handled = true
+          end
         ensure
           # If interrupted or failed, roll back the speculative compression message
           # so it doesn't pollute future conversation turns.
@@ -552,8 +583,6 @@ 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
@@ -606,11 +635,18 @@ module Clacky
         # user/assistant alternation for Bedrock Converse API.
         truncated_text = response[:content] || ""
         truncated_text = "..." if truncated_text.strip.empty?
-        @history.append({
+        truncated_msg = {
           role: "assistant",
           content: truncated_text,
           task_id: @current_task_id
-        })
+        }
+        # Preserve reasoning_content on truncated turns as well.
+        # This is the real LLM-emitted reasoning — keeping it here lets
+        # MessageHistory#to_api recognize we're in thinking mode and pad any
+        # other synthetic assistant messages in the history with an empty
+        # reasoning_content automatically (see message_history.rb).
+        truncated_msg[:reasoning_content] = response[:reasoning_content] if response[:reasoning_content]
+        @history.append(truncated_msg)
 
         # Insert system message to guide LLM to retry with smaller steps
         @history.append({
@@ -644,8 +680,12 @@ module Clacky
       end
       # Store token_usage in the message so replay_history can re-emit it
       msg[:token_usage] = response[:token_usage] if response[:token_usage]
-      # Preserve reasoning_content so it is echoed back to APIs that require it
-      # (e.g. Kimi/Moonshot extended thinking — omitting it causes HTTP 400)
+      # Preserve reasoning_content from the real LLM response.
+      # This is the authoritative signal used by MessageHistory#to_api to
+      # detect thinking-mode providers (DeepSeek V4, Kimi K2 thinking, etc.)
+      # and automatically pad any synthetic assistant messages with an empty
+      # reasoning_content so every outgoing payload satisfies the provider's
+      # "reasoning_content must be passed back" contract.
       msg[:reasoning_content] = response[:reasoning_content] if response[:reasoning_content]
       @history.append(msg)
 
@@ -744,21 +784,31 @@ module Clacky
           args[:working_dir] = @working_dir if @working_dir
 
           # 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
+          # always knows the agent is working. Using +with_progress+ wraps
+          # the execution in an +ensure+ block so the spinner/ticker is
+          # released even if the tool raises or the user interrupts.
+          #
+          # +quiet_on_fast_finish: true+ means "if the tool completes in
+          # under FAST_FINISH_THRESHOLD_SECONDS, remove the progress line
+          # instead of leaving a permanent 'Executing edit… (0s)' log
+          # entry". The preceding `[=>] Edit(...)` tool-call line and the
+          # following `[<=] Modified 1 occurrence` result line already
+          # tell the full story — the middle progress frame is noise for
+          # instant tools like edit/write/read/glob/grep. Truly slow
+          # tools (terminal running a build, web_fetch) exceed the
+          # threshold and their final frame is preserved as usual.
+          result = nil
           if @ui
             progress_message = build_tool_progress_message(call[:name], args)
-            @ui.show_progress(progress_message, prefix_newline: false)
-            progress_shown = true
-          end
-
-          begin
+            @ui.with_progress(
+              message: progress_message,
+              style: :quiet,
+              quiet_on_fast_finish: true
+            ) do
+              result = tool.execute(**args)
+            end
+          else
             result = tool.execute(**args)
-          ensure
-            @ui&.show_progress(phase: "done") if progress_shown
           end
 
           # Track modified files for Time Machine snapshots
@@ -990,12 +1040,34 @@ module Clacky
       # Switch to specified model if provided
       if model
         if model == "lite"
-          # Special keyword: use lite model if available, otherwise fall back to default
-          lite_model = subagent_config.lite_model
-          if lite_model && lite_model["id"]
-            subagent_config.switch_model_by_id(lite_model["id"])
+          # Special keyword: use lite model if available, otherwise fall back to default.
+          #
+          # Lite is now a *virtual* role — we don't require it to exist as a
+          # concrete entry in @models. Instead we derive it from whatever
+          # model the user is currently on (current_model), so switching
+          # primary models automatically re-pairs with the right lite
+          # companion (Claude → Haiku, DeepSeek V4-pro → V4-flash, ...).
+          lite_cfg = subagent_config.lite_model_config_for_current
+          if lite_cfg
+            if lite_cfg["virtual"]
+              # Provider-preset derived: apply the lite fields as a *session
+              # overlay* on the subagent's config — this intentionally avoids
+              # mutating the shared @models array / hashes which would pollute
+              # the parent agent's own current model (e.g. turning the parent's
+              # Opus entry into Haiku for the rest of the session).
+              subagent_config.apply_virtual_model_overlay!(
+                "api_key"          => lite_cfg["api_key"],
+                "base_url"         => lite_cfg["base_url"],
+                "model"            => lite_cfg["model"],
+                "anthropic_format" => lite_cfg["anthropic_format"]
+              )
+            elsif lite_cfg["id"]
+              # Explicit user-configured lite (from CLACKY_LITE_* env): a
+              # real @models entry with a stable id. Switch to it normally.
+              subagent_config.switch_model_by_id(lite_cfg["id"])
+            end
           end
-          # If no lite model, just use current (default) model
+          # If no lite is resolvable, just use current (primary) model.
         else
           # Regular model name lookup — find the first model with a matching
           # name and switch by its stable id.
@@ -1154,12 +1226,29 @@ module Clacky
     # Resolve image files to vision data_urls.
     # Files with data_url: use as-is (already compressed by frontend or adapter).
     # Files with path: convert to data_url via FileProcessor.
-    # Oversized images (> MAX_IMAGE_BYTES) are downgraded to disk file refs.
-    # @return [Array<String>, Array<Hash>] [vision_urls, downgraded_disk_files]
+    #
+    # Downgrade to disk file refs (with a `downgrade_reason` tag) when:
+    #   - :provider_no_vision — current model does not support vision input
+    #     (e.g. MiniMax, Kimi, DeepSeek, or openclacky's DeepSeek sidecar).
+    #     The downgrade is capability-driven and reflects the *current* model;
+    #     switching models takes effect on the next run with no cached state.
+    #   - :too_large — base64 payload exceeds MAX_IMAGE_BYTES. Downgrading here
+    #     keeps a hot context window from blowing up on e.g. a 20MB screenshot.
+    #
+    # Both reasons share the same downgrade path; `file_prompt` will later
+    # emit a `Note:` line on the file entry explaining why the image isn't
+    # inline, so the LLM has colocated context (no system prompt pollution).
+    #
+    # @return [Array<Hash>, Array<Hash>] [vision_images, downgraded_disk_files]
     private def resolve_vision_images(image_files)
       require "base64"
       max_bytes = Utils::FileProcessor::MAX_IMAGE_BYTES
-      vision_images = []  # Array of { url:, name:, size_bytes: }
+      # Capability check once per run — current_model_supports? is cheap and
+      # delegates to Providers.supports? under the hood, always reflecting
+      # the current model (no stale state on `/model` switch).
+      vision_supported = @config.current_model_supports?(:vision)
+
+      vision_images = []  # Array of { url:, name:, size_bytes:, path: }
       downgraded    = []
 
       image_files.each do |f|
@@ -1173,8 +1262,10 @@ module Clacky
           byte_size = (b64_data.bytesize * 3) / 4
           raw       = Base64.decode64(b64_data)
           file_ref  = Utils::FileProcessor.save_image_to_disk(body: raw, mime_type: mime, filename: name)
-          if byte_size > max_bytes
-            downgraded << { name: name, path: file_ref.original_path, type: "image", mime_type: mime, size_bytes: byte_size }
+          reason    = downgrade_reason_for(vision_supported, byte_size, max_bytes)
+          if reason
+            downgraded << { name: name, path: file_ref.original_path, type: "image",
+                            mime_type: mime, size_bytes: byte_size, downgrade_reason: reason }
           else
             vision_images << { url: data_url, name: name, size_bytes: byte_size, path: file_ref.original_path }
           end
@@ -1183,8 +1274,10 @@ module Clacky
             data_url_from_path = Utils::FileProcessor.image_path_to_data_url(path)
             b64_data  = data_url_from_path.split(",", 2).last.to_s
             byte_size = (b64_data.bytesize * 3) / 4
-            if byte_size > max_bytes
-              downgraded << { name: name, path: path, type: "image", mime_type: mime, size_bytes: byte_size }
+            reason    = downgrade_reason_for(vision_supported, byte_size, max_bytes)
+            if reason
+              downgraded << { name: name, path: path, type: "image",
+                              mime_type: mime, size_bytes: byte_size, downgrade_reason: reason }
             else
               vision_images << { url: data_url_from_path, name: name, size_bytes: byte_size, path: path }
             end
@@ -1197,6 +1290,30 @@ module Clacky
       [vision_images, downgraded]
     end
 
+    # Decide whether an image must be downgraded to a disk ref, and if so why.
+    # Precedence: provider capability is checked first — a text-only model
+    # can't use the image at any size, so there's no point re-checking size.
+    # @return [Symbol, nil] :provider_no_vision | :too_large | nil (keep inline)
+    private def downgrade_reason_for(vision_supported, byte_size, max_bytes)
+      return :provider_no_vision unless vision_supported
+      return :too_large if byte_size > max_bytes
+      nil
+    end
+
+    # Human-readable note for a downgrade reason, embedded next to the file
+    # entry in the file_prompt. Kept intentionally terse and factual; the LLM
+    # will see this alongside the file's name/type/path so it can tell the
+    # user honestly why it can't see the image.
+    # @return [String, nil] note text, or nil for no note
+    private def downgrade_note_for(reason)
+      case reason&.to_sym
+      when :provider_no_vision
+        "The current model does not support vision input. Image content is not visible to the model; suggest switching to a vision-capable model if the user needs image analysis."
+      when :too_large
+        "Image was too large for inline delivery and has been saved to disk. Read it with a vision-capable tool/model if needed."
+      end
+    end
+
     # Build user message content for LLM.
     # Returns plain String when no vision images; Array of content parts otherwise.
     # Build user message content for LLM.
@@ -1254,7 +1371,19 @@ module Clacky
     # Core method to inject session context (date, model, OS, paths).
     # Called by inject_session_context_if_needed (with date check)
     # and by switch_model (without date check, to force update).
+    #
+    # IMPORTANT: Skip injection when the system prompt hasn't been built yet.
+    # Otherwise, appending a user message to an empty history makes
+    # @history.empty? false, which causes run() to skip building the
+    # system prompt entirely (see run()'s "first run" guard).
+    # The injection will happen naturally in run() via
+    # inject_session_context_if_needed after the system prompt is in place.
     private def inject_session_context
+      # Don't inject context before system prompt exists — defer to
+      # inject_session_context_if_needed which runs inside run()
+      # after the system prompt has been built.
+      return unless @history.has_system_prompt?
+
       today   = Time.now.strftime("%Y-%m-%d")
       os      = Clacky::Utils::EnvironmentDetector.os_type
       desktop = Clacky::Utils::EnvironmentDetector.desktop_path