openclacky 0.9.38 → 1.0.0.beta.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43106e90c922f80d2bb342d051d68a6cb4efa045143c97b08c26bf776a952a6d
-  data.tar.gz: 1faee045587d15517d25ab68df5003c5a210db1d009b9b8363d6c27f0b53157d
+  metadata.gz: a6a51d00de51f04f142d6be7e3e726561384752ca02f44a6971eeaad9c2cdb28
+  data.tar.gz: 185e635750793082206332377649095313b62297a2bd2f9f0b825a523a499afb
 SHA512:
-  metadata.gz: 8e696b00d7e79c968851c1f5a194fe352d8d9f7971ca37f56321705dd83ec8a71a3cae1836468df94b3877d5ac6a25cf31c991f30e10d0997ec0a6b06b2c9825
-  data.tar.gz: 92628aced329eb6e7c9567034873a276a15a64692e3796cf995cfbe1303132d6720fc69115332ab69371d07e5f4963377c80a5bad568797619c58ecc48fca04c
+  metadata.gz: 66e14242f2d4b0e049fd45283c77c71919614d5f2ef8558b8635318f443afd41ab3ebf941a3b10a22c987805569082f699683af5eae23f5ef54e6dbd993e4931
+  data.tar.gz: 4734d321c296e168f505185e67bddf8967687fd4889871a9a148f8bc003a7bb866774eb4f8c15ab4aba8b27384ae28e1c436477b3dd65e898c90743b393dbfb9

data/.clacky/skills/gem-release/SKILL.md

@@ -3,7 +3,9 @@
 name: gem-release
 description: >-
   Automates the complete process of releasing a new version of the openclacky Ruby
-  gem
+  gem. Supports both stable releases (auto-increment) and pre-release versions
+  (user-specified, e.g., 1.0.0.beta.1). Handles version bumping, testing, building,
+  RubyGems publishing, GitHub Releases, and OSS CDN mirroring.
 disable-model-invocation: false
 user-invocable: true
 ---
@@ -21,6 +23,7 @@ This skill handles the entire gem release workflow from version bumping to publi
 To use this skill, simply say:
 - "Release a new version"
 - "Publish a new gem version"
+- "Release version 1.0.0.beta.1" (pre-release with explicit version)
 - Use the command: `/gem-release`
 
 ## Process Steps
@@ -31,10 +34,30 @@ To use this skill, simply say:
 - Ensure the repository is in a clean state
 
 ### 2. Version Management
+
+**Stable releases (default):**
 - Read current version from `lib/clacky/version.rb`
 - Increment version number (typically patch version: x.y.z → x.y.z+1)
 - Update the VERSION constant in the version file
 
+**Pre-release versions (when user specifies a version like `1.0.0.beta.1`):**
+- Accept the user-provided version string directly — do NOT auto-increment
+- The version must follow semver pre-release format: `X.Y.Z-<identifier>` or `X.Y.Z.<identifier>` (e.g., `1.0.0.beta.1`, `2.0.0-alpha`, `1.5.0-rc1`)
+- Before proceeding, warn the user about pre-release caveats (see Pre-Release Caveats below)
+
+### 2a. Pre-Release Caveats
+
+When releasing a pre-release version, inform the user of these known behaviors in the Clacky ecosystem:
+
+| Concern | Behavior | Impact |
+|---------|----------|--------|
+| **Version check notification** | RubyGems API returns the highest version number, including prereleases. `Gem::Version("0.9.38") < Gem::Version("1.0.0.beta.1")` → `true`. | ✅ The upgrade dot WILL appear in the Web UI for most users. |
+| **`gem update` (official source)** | `gem update openclacky --no-document` does NOT install prereleases without `--pre`. | ❌ Users on official RubyGems source who click "Upgrade" will see the notification but the upgrade will silently do nothing. |
+| **OSS CDN upgrade (mirror users)** | `upgrade_via_oss_cdn` downloads the exact `.gem` from `latest.txt` on OSS. | ⚠️ If you update `latest.txt` to point to the prerelease, mirror users WILL get the beta. |
+| **OSS `latest.txt`** | Stable users fetching `latest.txt` for fresh installs would get the beta. | ⚠️ By default, do NOT update `latest.txt` for pre-releases. Only update if this is intentional (e.g., a release candidate for broad testing). |
+
+**Action**: Ask the user whether to update `latest.txt` on OSS before proceeding. For internal testing, the answer is usually "no".
+
 ### 3. Quality Assurance
 - Run the full test suite with `bundle exec rspec`
 - Ensure all 167+ tests pass
@@ -93,15 +116,26 @@ To use this skill, simply say:
 
 4. **Create GitHub Release and Upload gem**
 
-   Extract the release notes for this version from CHANGELOG.md, then create a GitHub Release with the .gem file attached:
+   Extract the release notes for this version from CHANGELOG.md, then create a GitHub Release with the .gem file attached.
+
+   **For stable releases:**
    ```bash
    gh release create v{version} \
      --title "v{version}" \
-     --notes-file /tmp/release_notes.md \
+     --notes-file /tmp/release_notes_{version}.md \
      --latest \
      openclacky-{version}.gem
    ```
 
+   **For pre-release versions (e.g., `1.0.0.beta.1`):** use `--prerelease` instead of `--latest`:
+   ```bash
+   gh release create v{version} \
+     --title "v{version}" \
+     --notes-file /tmp/release_notes_{version}.md \
+     --prerelease \
+     openclacky-{version}.gem
+   ```
+
    Steps:
    - Parse the CHANGELOG.md section for `[{version}]`
    - Write it to a temp file (e.g., `/tmp/release_notes_{version}.md`) to avoid shell escaping issues
@@ -112,22 +146,28 @@ To use this skill, simply say:
 
 5. **Sync to Tencent Cloud OSS (CN mirror)**
 
-   After GitHub Release is created, upload the .gem file and update `latest.txt` on OSS so Chinese users can install without hitting GitHub directly:
+   After GitHub Release is created, upload the .gem file to OSS so Chinese users can install without hitting GitHub directly.
 
    ```bash
-   # Upload .gem file
+   # Upload .gem file (always do this for any release)
    coscli cp openclacky-{version}.gem cos://clackyai-1258723534/openclacky/openclacky-{version}.gem
+   ```
 
-   # Update latest.txt
+   **For stable releases only** — update `latest.txt` so fresh installs and mirror users pick up the new version:
+   ```bash
    echo "{version}" > /tmp/latest.txt
    coscli cp /tmp/latest.txt cos://clackyai-1258723534/openclacky/latest.txt
 
    # Verify
    curl -fsSL https://oss.1024code.com/openclacky/latest.txt
    ```
-
    Expected output of verify: `{version}`
 
+   **For pre-release versions** — do NOT update `latest.txt` unless the user explicitly requested it. Updating `latest.txt` to a prerelease would cause:
+   - Mirror users clicking "Upgrade" to get the beta via `upgrade_via_oss_cdn`
+   - Fresh installs via the install script to get the beta
+   - Only skip this if the user explicitly wants broad beta distribution
+
    > **Prerequisite**: `coscli` installed at `/usr/local/bin/coscli` and configured at `~/.cos.yaml`
 
 6. **Sync scripts/ to OSS**
@@ -325,22 +365,34 @@ git tag vX.Y.Z
 git push origin main
 git push origin --tags
 
-# Create GitHub Release with .gem asset (requires gh CLI)
-# 1. Extract release notes from CHANGELOG.md for this version
-# 2. Write to temp file to avoid shell escaping issues
-# 3. Create the release and attach .gem file
+# ── GitHub Release ──────────────────────────────────────────────────────
+
+# Stable release:
 gh release create vX.Y.Z \
   --title "vX.Y.Z" \
   --notes-file /tmp/release_notes_X.Y.Z.md \
   --latest \
   openclacky-X.Y.Z.gem
 
-# Sync to Tencent Cloud OSS (CN mirror)
+# Pre-release (use --prerelease instead of --latest):
+gh release create vX.Y.Z-beta.1 \
+  --title "vX.Y.Z-beta.1" \
+  --notes-file /tmp/release_notes_X.Y.Z-beta.1.md \
+  --prerelease \
+  openclacky-X.Y.Z.beta.1.gem
+
+# ── OSS CDN (CN mirror) ─────────────────────────────────────────────────
+
+# Always upload the .gem file:
 coscli cp openclacky-X.Y.Z.gem cos://clackyai-1258723534/openclacky/openclacky-X.Y.Z.gem
+
+# Stable releases ONLY — update latest.txt:
 echo "X.Y.Z" > /tmp/latest.txt
 coscli cp /tmp/latest.txt cos://clackyai-1258723534/openclacky/latest.txt
 curl -fsSL https://oss.1024code.com/openclacky/latest.txt  # verify
 
+# Pre-releases — skip latest.txt update unless user explicitly requests it
+
 # Sync scripts/ to OSS (build from templates first)
 bash scripts/build/build.sh
 for script in scripts/*; do
@@ -365,8 +417,10 @@ curl -fsSL https://oss.1024code.com/clacky-ai/openclacky/main/scripts/install.sh
 - Git repository updated with version tag
 - CHANGELOG.md updated with release notes
 - GitHub Release created with .gem file attached at https://github.com/clacky-ai/openclacky/releases
+  - Use `--latest` for stable releases, `--prerelease` for pre-releases
 - .gem file uploaded to OSS: https://oss.1024code.com/openclacky/openclacky-{version}.gem
-- latest.txt updated on OSS: https://oss.1024code.com/openclacky/latest.txt returns the new version
+- For stable releases: `latest.txt` updated on OSS: https://oss.1024code.com/openclacky/latest.txt returns the new version
+- For pre-releases: `latest.txt` NOT updated (unless user explicitly opts in)
 - No build or deployment errors
 - User-facing release summary presented at the end
 

data/CHANGELOG.md

@@ -7,6 +7,46 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.0.beta.2] - 2026-04-27
+
+### Added
+- **New session creation supports model & working-directory options.** The Web UI "new session" dialog now lets you pick the model and starting directory up front, instead of having to adjust them after the session opens.
+
+### Fixed
+- **System prompt now refreshes when you switch models.** Previously the system prompt captured at session start stuck around even after `/model` or `/provider` switches, which could leave model-specific instructions out of sync. The agent now re-injects the correct system prompt on every model change.
+- **Port 7070 properly released when the terminal tool exits.** A lingering listener on port 7070 could block subsequent runs; the terminal tool now cleans it up on shutdown.
+- **Windows installer uses `[IO.Path]::GetTempPath()` for the temp directory** (#58) — more reliable than `$env:TEMP` on systems where the env var is unset or points to a non-ASCII path.
+
+## [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.