openclacky 0.9.37 → 1.0.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 951665db04cf6c2a4f8ef9b5c0555f4df91b84af08f63d21097d97cbd64d44b2
-  data.tar.gz: 82457a522007f54ecd5fcc36fee8e79cf16a65996dd9b95d7a00fd0dcfbc2cac
+  metadata.gz: b0938f51d788566d1c708a0054a3b45565f0f3b2ea7cd68f9e18897247c745cd
+  data.tar.gz: 96bef1e4b6333fcee57e26fb330f12d7d5b9f79f470a34f35483ab5f51571e64
 SHA512:
-  metadata.gz: 031b1031a702aca3a7cee36ea8ba23bc4982e95f8381e59d07ecb652432f6bc8a40e9a386e4a254d640f18f0088d9e18fa1f6434d92c038844f4821cef40a703
-  data.tar.gz: 5c5c36517efebb37a7a44d0531e0baadedb8600319682c39696a971771852019f2649386e15a3505d9ae32e86cf8c5818c64cf36943247220a7db6e0df24e994
+  metadata.gz: 59ba5927fef6187d4d862f210282190b589838e4950b0a5bf0e37731e6cd772bba0d4bfd483d6ff14f979eabf7a4dc09abacb2c60f98df7762af6b4191dc67cf
+  data.tar.gz: 52063a91b64281d4dcf3e6bd8e3f4d87cc63cfed70169c87cfacf55e4f6c1cb16f2d938a9f554f564829e879755573d3eb8fb3988260285d11087dfa0058473d

data/CHANGELOG.md

@@ -7,6 +7,36 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.0.beta.1] - 2026-04-26
+
+### Added
+- **Vision support — agents can now "see" images.** When you attach image files (PNG, JPG, GIF, WebP), the agent can analyze them visually with vision-capable models. Non-vision models automatically fall back to disk references instead of breaking.
+- **DeepSeek V4 (Clacky-DS) provider.** New `deepseekv4` provider preset with native DeepSeek API endpoint, supporting `deepseek-v4-pro` and `deepseek-v4-flash` models with accurate pricing.
+- **Memory subagent.** Long-term memory management now runs as a dedicated background subagent — writes memories when the task reaches meaningful completion, instead of on every turn.
+- **Usage telemetry.** Anonymous usage data collection helps us understand how the product is used and prioritize improvements. No personal or conversation data is collected.
+- **Brand configuration auto-refresh.** White-label brand settings now refresh automatically when the WebUI starts up, no manual restart needed.
+
+### Improved
+- **Progress handles revamped.** Nested progress handles now hide/show automatically, ticker threads keep animations smooth, and fast-completing tasks no longer flash a pointless "done" message.
+- **Todo manager tool upgrades.** Batch add/remove multiple todos at once, and completed todos auto-clear when you add new ones.
+- **Model switching more robust.** CLI slash commands (`/model`, `/provider`) now work seamlessly, server-side routing handles dynamic endpoints correctly, and switching between all provider types is more reliable.
+
+### Fixed
+- **Access key now persists via cookies.** The WebUI login key was stored only in `localStorage`, causing WebSocket connections to lose authentication. Now also written to a `clacky_access_key` cookie for consistent auth across all connection types.
+- **MiniMax → DeepSeek switch error.** Switching models from MiniMax to DeepSeek no longer fails due to mismatched message format handling.
+- **Bedrock truncated tool call recovery.** When AWS Bedrock truncates a tool call mid-argument, the agent now detects the error, sends feedback, and successfully retries on the next turn.
+- **Sidebar "Load More" scroll jump.** Clicking "Load More" at the bottom of the session list no longer jerks the sidebar back to the active session — scroll position is now preserved.
+- **Double-render regression.** An output buffer lifecycle bug that occasionally caused duplicate content in the terminal UI has been fixed.
+- **DeepSeek V4 message content extraction.** Compression no longer mishandles DeepSeek V4's user message content format.
+
+## [0.9.38] - 2026-04-24
+
+### Fixed
+- **Access key now persists correctly via cookie**. When the Web UI server was configured with `--access-key`, the key entered at login was stored only in `localStorage` — but WebSocket connections and some API requests read the key from cookies. This mismatch caused authenticated sessions to sporadically lose access (e.g. WebSocket falling back to unauthorized). The auth flow now writes the key to both `localStorage` _and_ a `clacky_access_key` cookie, and probes the server using the cookie. Incorrect keys are cleared from both stores before retry. Up to 3 attempts are allowed before giving up.
+
+### More
+- Auth prompt input field now uses `type="password"` while the user is typing (reverts to text after), preventing shoulder-surfing
+
 ## [0.9.37] - 2026-04-24
 
 ### Fixed

data/lib/clacky/agent/llm_caller.rb

@@ -54,14 +54,25 @@ module Clacky
         max_retries = 10
         retry_delay = 5
         retries = 0
+        # One-shot flag set by the BadRequestError rescue below when the server
+        # complained about missing reasoning_content. The subsequent retry will
+        # pad every assistant message's reasoning_content, which satisfies
+        # DeepSeek / Kimi thinking-mode providers even when the earlier turns
+        # were produced by a different provider (e.g. MiniMax keeps thinking
+        # inline in content and never emits a reasoning_content field, so the
+        # history-evidence heuristic in MessageHistory can't infer thinking
+        # mode on its own). We retry at most once — if padding doesn't fix it,
+        # the error is something else and we let it propagate.
+        force_reasoning_content_pad = false
+        thinking_retry_attempted = false
 
         begin
           # Use active_messages (Time Machine) when undone, otherwise send full history.
           # to_api strips internal fields and handles orphaned tool_calls.
           messages_to_send = if respond_to?(:active_messages)
-            active_messages
+            active_messages(force_reasoning_content_pad: force_reasoning_content_pad)
           else
-            @history.to_api
+            @history.to_api(force_reasoning_content_pad: force_reasoning_content_pad)
           end
 
           response = @client.send_messages_with_tools(
@@ -137,6 +148,25 @@ module Clacky
           # Progress cleanup is the caller's responsibility (via its own ensure block).
           raise AgentError, "[LLM] Service unavailable after #{current_max} retries"
         end
+
+        rescue Clacky::BadRequestError => e
+          # One-shot recovery for thinking-mode providers (DeepSeek V4, Kimi K2)
+          # that require every assistant message in the history to carry a
+          # reasoning_content field. The history-evidence heuristic in
+          # MessageHistory#to_api can miss this when the preceding turns came
+          # from a different thinking style (e.g. MiniMax keeps <think>...</think>
+          # inline in content and never emits reasoning_content) — so we detect
+          # the error here and retry once with forced padding.
+          if !thinking_retry_attempted && reasoning_content_missing_error?(e)
+            thinking_retry_attempted = true
+            force_reasoning_content_pad = true
+            Clacky::Logger.info(
+              "[thinking-mode] retrying with forced reasoning_content padding " \
+              "(model=#{@config.model_name.inspect} base_url=#{@config.base_url.inspect})"
+            )
+            retry
+          end
+          raise
         end
 
         # Track cost and collect token usage data.
@@ -183,6 +213,22 @@ module Clacky
           "Continuing with fallback model: #{fallback}"
         )
       end
+
+      # True when a 400 BadRequestError is specifically about a missing
+      # reasoning_content field in thinking mode (DeepSeek V4, Kimi K2 thinking).
+      # We require TWO distinct substrings to avoid false positives — a generic
+      # 400 that happens to mention "reasoning_content" in passing (e.g. a
+      # validation hint in some unrelated provider) must NOT trigger the pad
+      # retry, which would silently add an empty field to every assistant
+      # message in the history.
+      private def reasoning_content_missing_error?(err)
+        return false unless err.is_a?(Clacky::BadRequestError)
+
+        msg = err.message.to_s.downcase
+        msg.include?("reasoning_content") &&
+          (msg.include?("thinking") || msg.include?("must be passed back") ||
+           msg.include?("must be provided"))
+      end
     end
   end
 end

data/lib/clacky/agent/memory_updater.rb

@@ -2,17 +2,34 @@
 
 module Clacky
   class Agent
-    # Long-term memory update functionality
-    # Triggered at the end of a session to persist important knowledge.
+    # Long-term memory update functionality.
     #
-    # The LLM decides:
+    # Runs at the end of a qualifying task to persist important knowledge
+    # into ~/.clacky/memories/. The LLM decides:
     #   - Which topics were discussed
     #   - Which memory files to update or create
     #   - How to merge new info with existing content
     #   - What to drop to stay within the per-file token limit
     #
+    # Architecture:
+    #   Memory update runs as a **forked subagent**, NOT inline in the
+    #   main agent's loop. The subagent inherits the main agent's history
+    #   (so it can see what happened) via +fork_subagent+'s standard
+    #   deep-clone, and inherits the same model/tools so prompt-cache is
+    #   reused maximally. The subagent runs synchronously; when it returns,
+    #   the main agent prints +show_complete+.
+    #
+    #   This gives us, structurally:
+    #     - Clean main-agent history (no memory_update messages to clean up)
+    #     - Correct visual ordering ([OK] Task Complete is the LAST thing
+    #       printed — the memory-update progress finishes before it)
+    #     - Independent cost accounting (task cost vs. memory update cost)
+    #     - Natural recursion guard (+@is_subagent+ blocks re-entry)
+    #
     # Trigger condition:
-    #   - Iteration count >= MEMORY_UPDATE_MIN_ITERATIONS (avoids trivial tasks like commits)
+    #   - Iteration count >= MEMORY_UPDATE_MIN_ITERATIONS (skip trivial tasks)
+    #   - Not already a subagent (no recursion)
+    #   - Memory update is enabled in config
     module MemoryUpdater
       # Minimum LLM iterations for this task before triggering memory update.
       # Set high enough to skip short utility tasks (commit, deploy, etc.)
@@ -32,37 +49,79 @@ module Clacky
         task_iterations >= MEMORY_UPDATE_MIN_ITERATIONS
       end
 
-      # Inject memory update prompt into @messages so the main agent loop handles it.
-      # Builds the prompt dynamically, injecting the current memory file list so the
-      # LLM doesn't need to scan the directory itself.
-      # Returns true if prompt was injected, false otherwise.
-      def inject_memory_prompt!
-        return false unless should_update_memory?
-        return false if @memory_prompt_injected
-
-        @memory_prompt_injected = true
-        @memory_updating = true
-        @ui&.show_progress("Updating long-term memory…")
-
-        @history.append({
-          role: "user",
-          content: build_memory_update_prompt,
-          system_injected: true,
-          memory_update: true
-        })
-
-        true
-      end
-
-      # Clean up memory update messages from conversation history after loop ends.
-      # Call this once after the main loop finishes.
-      def cleanup_memory_messages
-        return unless @memory_prompt_injected
-
-        @history.delete_where { |m| m[:memory_update] }
-        @memory_prompt_injected = false
-        @memory_updating = false
-        @ui&.show_progress(phase: "done")
+      # Run memory update as a forked subagent.
+      #
+      # This is called by +Agent#run+ on the success path, AFTER the main
+      # loop exits and BEFORE +show_complete+ is printed. It blocks until
+      # the subagent finishes, so the visual order is structurally correct:
+      #
+      #   ... task output ...
+      #   [progress] Updating long-term memory… (spinner)
+      #   [progress finishes]
+      #   [OK] Task Complete
+      #
+      # Safe to call unconditionally; returns early if preconditions fail.
+      # Never raises for "no update needed" — only propagates genuine errors
+      # (+Clacky::AgentInterrupted+ for Ctrl+C, other exceptions are caught
+      # and logged so memory-update failures never mask the parent task's
+      # result).
+      def run_memory_update_subagent
+        return unless should_update_memory?
+
+        handle = @ui&.start_progress(message: "Updating long-term memory…", style: :primary)
+
+        # Fork subagent inheriting main agent's model, tools, and history.
+        # Maximizes prompt-cache reuse: same model, same tool set, same
+        # cloned history — only the +system_prompt_suffix+ (the memory
+        # update instructions) and the final "Please proceed." user turn
+        # are new, landing on top of a warm cache.
+        subagent = fork_subagent(system_prompt_suffix: build_memory_update_prompt)
+
+        # Memory update is a background consolidation task — never prompt
+        # the user for confirmation on memory file writes. The subagent
+        # has its own config copy (fork_subagent does deep_copy), so this
+        # doesn't affect the parent.
+        sub_config = subagent.instance_variable_get(:@config)
+        sub_config.permission_mode = :auto_approve if sub_config.respond_to?(:permission_mode=)
+
+        begin
+          result = subagent.run("Please proceed.")
+        rescue Clacky::AgentInterrupted
+          # User pressed Ctrl+C during memory update. Propagate so the
+          # parent agent's interrupt handler runs.
+          raise
+        rescue StandardError => e
+          # Memory update failures are NEVER fatal to the parent task.
+          # Log and move on — the user's actual work is already done.
+          @debug_logs << {
+            timestamp: Time.now.iso8601,
+            event: "memory_update_error",
+            error_class: e.class.name,
+            error_message: e.message,
+            backtrace: e.backtrace&.first(10)
+          }
+          Clacky::Logger.error("memory_update_error", error: e)
+          return
+        ensure
+          handle&.finish
+        end
+
+        return unless result
+
+        # Merge subagent cost into parent's cumulative session spend so the
+        # sessionbar shows the real total. The parent's task-complete cost
+        # (result[:total_cost_usd] in Agent#run) stays unaffected — it
+        # still reflects ONLY the user's task, not the memory update.
+        subagent_cost = result[:total_cost_usd] || 0.0
+        @total_cost += subagent_cost
+        @ui&.update_sessionbar(cost: @total_cost, cost_source: @cost_source)
+
+        # Only surface a completion info line if the subagent actually
+        # wrote something to memory. The common "No memory updates needed."
+        # path stays silent to avoid visual noise.
+        if subagent_wrote_memory?(subagent)
+          @ui&.show_info("Memory updated: #{result[:iterations]} iterations, $#{subagent_cost.round(4)}")
+        end
       end
 
       private def memory_update_enabled?
@@ -72,6 +131,43 @@ module Clacky
         @config.memory_update_enabled != false
       end
 
+      # Inspect the subagent's history for a successful write/edit tool
+      # call targeting a memory file. Used to decide whether to surface a
+      # "Memory updated" info line (option C — silent when nothing changed).
+      # @param subagent [Clacky::Agent]
+      # @return [Boolean]
+      private def subagent_wrote_memory?(subagent)
+        return false unless subagent.respond_to?(:history) && subagent.history
+
+        subagent.history.to_a.any? do |msg|
+          next false unless msg.is_a?(Hash)
+
+          # Match OpenAI-style tool_calls on assistant messages …
+          tool_calls = msg[:tool_calls] || msg["tool_calls"]
+          if tool_calls.is_a?(Array) && tool_calls.any?
+            next true if tool_calls.any? do |tc|
+              name = tc.dig(:function, :name) || tc.dig("function", "name") || tc[:name] || tc["name"]
+              %w[write edit].include?(name.to_s)
+            end
+          end
+
+          # … and Anthropic-style content blocks with type=tool_use.
+          content = msg[:content] || msg["content"]
+          if content.is_a?(Array)
+            next true if content.any? do |block|
+              block.is_a?(Hash) &&
+                (block[:type] == "tool_use" || block["type"] == "tool_use") &&
+                %w[write edit].include?((block[:name] || block["name"]).to_s)
+            end
+          end
+
+          false
+        end
+      rescue StandardError
+        # Defensive: never let introspection errors break memory update.
+        false
+      end
+
       # Build the memory update prompt with the current memory file list injected.
       # Uses a whitelist approach: default is NO write, only write if explicit criteria are met.
       # @return [String]

data/lib/clacky/agent/message_compressor.rb

@@ -125,8 +125,25 @@ module Clacky
     end
 
     def parse_compressed_result(result, chunk_path: nil)
-      # Return the compressed result as a single assistant message
-      # Keep the <summary> tags as they provide semantic context
+      # Return the compressed result as a single user message (role: "user").
+      #
+      # Why role:"user" instead of "assistant":
+      #   When all original user messages get archived into the chunk during compression
+      #   (e.g. a long single-turn `/slash` task), the rebuilt history can end up as
+      #   `system → assistant(summary) → assistant(tool_calls) → tool → …` with NO user
+      #   message anywhere. Strict providers (notably DeepSeek V4 thinking mode) reject
+      #   this as a malformed turn structure with a misleading
+      #   "reasoning_content must be passed back" 400 error.
+      #
+      # Marking it as a user message gives the conversation a valid turn boundary.
+      # `system_injected: true` ensures the UI's replay_history still hides it from
+      # the chat panel (the real-user filter excludes system_injected messages), while
+      # INTERNAL_FIELDS in MessageHistory strips the marker before the API payload is
+      # built — so DeepSeek/OpenAI/Anthropic only see a plain `{role:"user", content:…}`.
+      #
+      # The `compressed_summary: true` flag is preserved so that replay_history still
+      # routes this message through the chunk-expansion path (which keys off that flag,
+      # not the role).
       content = result.to_s.strip
 
       if content.empty?
@@ -142,7 +159,17 @@ module Clacky
           content_without_topics = content_without_topics + anchor
         end
 
-        [{ role: "assistant", content: content_without_topics, compressed_summary: true, chunk_path: chunk_path }]
+        # Prefix lets the model recognise this is injected context, not a user utterance.
+        framed_content = "[Compressed conversation summary — previous turns archived]\n\n" \
+                         "#{content_without_topics}"
+
+        [{
+          role: "user",
+          content: framed_content,
+          compressed_summary: true,
+          chunk_path: chunk_path,
+          system_injected: true
+        }]
       end
     end
   end

data/lib/clacky/agent/message_compressor_helper.rb

@@ -15,11 +15,10 @@ module Clacky
       # Trigger compression during idle time (user-friendly, interruptible)
       # Returns true if compression was performed, false otherwise
       def trigger_idle_compression
-        # Check if we should compress (force mode)
+        # Check if we should compress (force mode) BEFORE opening any UI, so
+        # "skipped" doesn't flash a spinner on screen.
         compression_context = compress_messages_if_needed(force: true)
-        @ui&.show_progress("Idle detected. Compressing conversation to optimize costs...", progress_type: "idle_compress", phase: "active")
         if compression_context.nil?
-          @ui&.show_progress("Idle skipped.", progress_type: "idle_compress", phase: "done")
           Clacky::Logger.info(
             "Idle compression skipped",
             enable_compression: @config.enable_compression,
@@ -31,23 +30,44 @@ module Clacky
           return false
         end
 
-        # Insert compression message
+        # Own the progress indicator through +with_progress+: the ensure
+        # block guarantees the spinner/ticker is released even when the
+        # user interrupts mid-way (AgentInterrupted from current thread)
+        # or the LLM call fails. No more orphan gray tickers.
+        #
+        # When @ui is nil (tests / headless) we still need to run the
+        # compression work — safe-navigation with a block would silently
+        # skip it, so branch explicitly.
         compression_message = compression_context[:compression_message]
         @history.append(compression_message)
 
-        begin
-          # Execute compression using shared LLM call logic
-          response = call_llm
-          handle_compression_response(response, compression_context)
-          true
-        rescue Clacky::AgentInterrupted => e
-          @ui&.log("Idle compression canceled: #{e.message}", level: :info)
-          @history.rollback_before(compression_message)
-          false
-        rescue => e
-          @ui&.log("Idle compression failed: #{e.message}", level: :error)
-          @history.rollback_before(compression_message)
-          false
+        run_compression = lambda do |handle|
+          begin
+            response = call_llm
+            handle_compression_response(response, compression_context, progress: handle)
+            true
+          rescue Clacky::AgentInterrupted => e
+            @ui&.log("Idle compression canceled: #{e.message}", level: :info)
+            @history.rollback_before(compression_message)
+            false
+          rescue => e
+            @ui&.log("Idle compression failed: #{e.message}", level: :error)
+            @history.rollback_before(compression_message)
+            false
+          end
+        end
+
+        if @ui
+          result = nil
+          @ui.with_progress(
+            message: "Idle detected. Compressing conversation to optimize costs...",
+            style: :quiet
+          ) do |handle|
+            result = run_compression.call(handle)
+          end
+          result
+        else
+          run_compression.call(nil)
         end
       end
 
@@ -117,7 +137,14 @@ module Clacky
       end
 
       # Handle compression response and rebuild message list
-      def handle_compression_response(response, compression_context)
+      # @param response [Hash] LLM response
+      # @param compression_context [Hash] context returned by +compress_messages_if_needed+
+      # @param progress [#finish, nil] Owned progress handle from the caller's
+      #   with_progress block. When provided, the final summary message is
+      #   delivered via +progress.finish(final_message: ...)+ instead of the
+      #   legacy +show_progress(phase: "done")+ — this lets +ensure+ in the
+      #   caller guarantee cleanup even if this method raises mid-way.
+      def handle_compression_response(response, compression_context, progress: nil)
         # Extract compressed content from response
         compressed_content = response[:content]
 
@@ -168,7 +195,14 @@ module Clacky
         # Show compression info (use estimated tokens from rebuilt history)
         compression_summary = "History compressed (~#{compression_context[:original_token_count]} -> ~#{@history.estimate_tokens} tokens, " \
           "level #{compression_context[:compression_level]})"
-        @ui&.show_progress(compression_summary, progress_type: "idle_compress", phase: "done")
+        if progress
+          # Owned-handle path: the caller's ensure block will still call
+          # handle.finish; finishing here with a final_message means that
+          # later finish (with no final_message) is a no-op (idempotent).
+          progress.finish(final_message: compression_summary)
+        else
+          @ui&.show_progress(compression_summary, progress_type: "idle_compress", phase: "done")
+        end
       end
 
       # Get recent messages while preserving tool_calls/tool_results pairs.

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.