openclacky 1.5.15 → 1.5.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 878e99c7061a59dee8c50f4ec416986c33c7d93538595e90719042827a9b774e
-  data.tar.gz: 51a940cdc2e2f25b95a6ce96d84cd7c45988154b324ca2c9962bcddf4f213fa4
+  metadata.gz: 9939ab09ac4e473dc7b096dac6a14c67f6d6060fe7678d7bd0b2635c7cc924ed
+  data.tar.gz: 9e0e566a77267f73388a9761d101672c86fd35513dc7248355a3c3df7d8017f6
 SHA512:
-  metadata.gz: 82af0b7e1e966e3e8eafc888006a05e75f637b6d6508721432bc484394f9699cb2a82ad0f0abee73cd88214bcad6e865acf8e1840e357059a470aee5e59f00c5
-  data.tar.gz: f996cf6c38e1070608dd49955e68c1154301152b8fc51d0e3e392055dcd51bebc21c234e0bf20fddbdb0a2a9ba48dcc527afcfd1e92e43fc2fc82a1ddbbcfa33
+  metadata.gz: 206657c6e08b40482a5029abf25fb8bd8579728ea469e2b2f7fba5b0f95dbbbcbfb8ca75778f73090bbbb34d7145cf58dab64c7d7462325d981a4e5106ced23e
+  data.tar.gz: 0b30e40beb4d544076f2063160d04d9fcc2099b43ce46c78e1694d35ec631859361ffc15b2521a8a53e0c0cd84fb52e157cebf4469557991f273770842808568

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

@@ -95,15 +95,25 @@ This is the one step the agent handles manually — the script does not write ch
      ```bash
      gh api orgs/clacky-ai/members --paginate --jq '.[].login' | sort
      ```
-   - Then cross-reference PR authors in the release range:
+   - Then cross-reference PR authors in the release range. Use `grep -oE`, not `-oP` —
+     BSD grep on macOS rejects `-P` with "invalid option", and the loop silently yields nothing:
      ```bash
-     git log <previous_tag>..HEAD --oneline | grep -oP '#\d+' | while read pr; do
+     git log <previous_tag>..HEAD --oneline | grep -oE '#[0-9]+' | while read pr; do
        num=${pr#\#}
        gh pr view $num --json number,author --jq '"#\(.number) \(.author.login)"'
      done
      ```
    - Skip attribution for org members (internal contributors) - only call out external contributors
-   - If a PR was closed and resubmitted, use the merged PR number
+   - Some cited numbers no longer resolve at all. A commit subject can name a superseded PR
+     next to the merged one (`feat: discover custom-endpoint models in the add-model dialog
+     (#559) (#560)`), and `gh pr view 559` answers "Could not resolve to a PullRequest".
+     When that happens, ask the commit which PR actually merged it:
+     ```bash
+     gh api repos/clacky-ai/openclacky/commits/<sha>/pulls \
+       --jq '.[] | "PR #\(.number) | \(.user.login) | \(.state)"'
+     ```
+     Attribute the bullet to the PR that resolves and carries a real author; a number that
+     resolves to nobody is not a contributor reference.
    - Example: `- Todo panel with SVG icons (#437 - @shipinliang)`
 
 6. Commit the changelog:

data/CHANGELOG.md

@@ -4,6 +4,46 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
+## [1.5.16] - 2026-09-24
+
+### Added
+- Add Claude Opus 5.5 and GPT-6 Sol/Luna to the model catalog
+- Send task progress cards in Feishu, with collapsible process history (#582)
+- Print a receipt-style usage scorecard from the billing page and share it as an image
+- Understand video attachments through a sidecar model (#564)
+- Open the app straight into a chat from an external clacky:// link, including the welcome view
+- Route requests automatically: the auto alias picks a tier per request and reports which tier served it (#576)
+- Drive the Windows desktop through WSL in computer-use
+- Ship computer-use as a default-off extension
+- Let on_start hooks veto a turn before the agent starts (#573 - @afumu)
+- Cap the memory and CPU of a task's shells and browser daemons on Linux hosts with --task-cgroup
+- Refuse to start on a taken port instead of silently moving to another one, with --strict-port
+- Keep attachment paths when a compressed history chunk is replayed (#581 - @BoyYangzai)
+- Point generated skills at their own directory through an inlined skill_dir
+
+### Improved
+- Restyle the web search result card (#575)
+- Use official brand marks for model vendor badges (#566)
+- Refresh the supported model catalogs and pricing (#571)
+- Rename the extension group label User to Personal
+- Adjust the session title size and unify the sidebar active highlight
+- Soften the extension row action buttons and tighten the segmented control corners
+
+### Fixed
+- Keep queued guidance attached to the message it was sent from, and allow cancelling it (#584, #578)
+- Stop treating a pasted path as a slash command (#577)
+- Restore structured tool result cards when a session history is replayed (#574)
+- Stop duplicating user bubbles after an edit (#568)
+- Show attachment badges in realtime user bubbles (#567)
+- Transcribe audio attachments through the STT sidecar (#565)
+- Preserve a quote selection while a live update streams in (#569)
+- Load per-key platform usage in parallel in the billing view (#580)
+- Prevent subagents from publishing input queues (#570 - @afumu)
+- Block model switching while a session is running instead of racing the running turn
+- Hand binary files back to the OS when they are reopened
+- Report the doctor host before resolving the backend
+- Stop the DeepSeek preset from showing a version suffix
+
 ## [1.5.15] - 2026-09-17
 
 ### Added

data/README.md

@@ -185,6 +185,17 @@ openclacky server --port 8080        # custom port
 openclacky server --host 0.0.0.0     # listen on all interfaces (remote access)
 ```
 
+Linux sandbox hosts can opt into task limits with
+`openclacky server --task-cgroup /sys/fs/cgroup/tasks`. The host must first create
+that cgroup, configure its aggregate memory/CPU limits, and enable the `memory`
+and `cpu` subtree controllers. Terminal shells and browser MCP daemons enter
+child groups before exec; the server remains outside. Terminal results include
+`resource_exhausted: "memory"` and an error when their group records an OOM kill,
+even if the shell masks the child's failure. A separately managed Chrome must
+also be placed under the same parent by its launcher. This option is off by
+default and does not establish a security boundary against privileged commands.
+
+
 ## Configuration
 
 ```bash

data/lib/clacky/agent/hook_manager.rb

@@ -25,7 +25,11 @@ module Clacky
     end
 
     # @return [Hash] `{action: :allow}`, `{action: :deny, reason:}`, or
-    #   `{action: :handled, result:}` when a hook fulfilled the call itself.
+    #   `{action: :handled, result:}` when a hook fulfilled the event itself.
+    # on_start receives (user_input, agent) after task/history initialization.
+    # Its handled result is returned unchanged from Agent#run; the extension
+    # supplies the run-result status and any queue/feedback flags it needs.
+    # on_start is not fired for steering input inside an already running turn.
     # Extra trailing arg: the agent that owns this hook chain, so ext hooks can
     # call `agent.emit_event(...)`. Blocks are procs — those declaring fewer
     # params (`|call|`, `|call, result|`) silently ignore it.
@@ -43,8 +47,8 @@ module Clacky
           # place (chained rewrite), so for non-deny results there's nothing to
           # merge — we just keep going.
           #
-          # :handled short-circuits the same way — the hook has already produced
-          # the tool's result, so later hooks have nothing left to act on.
+          # :handled short-circuits the same way: the hook has already fulfilled
+          # the event, so later hooks have nothing left to act on.
           if hook_result[:action] == :deny || hook_result[:action] == :handled
             result = hook_result
             break

data/lib/clacky/agent/llm_caller.rb

@@ -45,7 +45,7 @@ module Clacky
       #   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
+      private def call_llm(agent_upstream_fails: nil, agent_upgrade_fails: nil)
         # Transition :fallback_active → :probing if cooling-off has expired.
         @config.maybe_start_probing
 
@@ -54,6 +54,12 @@ module Clacky
         max_retries = 10
         retry_delay = 5
         retries = 0
+        # Per-call tier attribution for auto routing: each retryable failure is
+        # charged to the tier the gateway actually routed that call to (echoed
+        # in X-Clacky-Routed-Tier). Failures without a tier (network layer,
+        # timeouts — the gateway never answered) are not attributed to either.
+        floor_fails = 0
+        upgrade_fails = 0
 
         # Track whether any of the retry/fallback branches below opened a
         # "retrying" progress slot via show_progress(progress_type:
@@ -111,7 +117,9 @@ module Clacky
             max_tokens: @config.max_tokens,
             enable_caching: @config.enable_prompt_caching,
             reasoning_effort: @reasoning_effort,
-            on_chunk: build_progress_on_chunk
+            on_chunk: build_progress_on_chunk,
+            agent_upstream_fails: (agent_upstream_fails || 0) + floor_fails,
+            agent_upgrade_fails: (agent_upgrade_fails || 0) + upgrade_fails
           )
 
           # Successful response — if we were probing, confirm primary is healthy.
@@ -142,7 +150,7 @@ module Clacky
               finish_reason: response[:finish_reason].to_s,
               completion_tokens: response.dig(:token_usage, :completion_tokens)
             )
-            raise RetryableError, "[LLM] Model returned empty response (no content, no tool_calls), retrying..."
+            raise RetryableError.new("[LLM] Model returned empty response (no content, no tool_calls), retrying...", routed_tier: response[:routed_tier])
           end
 
           # Thinking-mode silent response detector. DeepSeek V4 / Kimi K2 /
@@ -164,7 +172,7 @@ module Clacky
               reasoning_tail: reasoning_str[-200, 200] || reasoning_str,
               completion_tokens: response.dig(:token_usage, :completion_tokens)
             )
-            raise RetryableError, "[LLM] Thinking-mode model produced reasoning but empty content/tool_calls, retrying..."
+            raise RetryableError.new("[LLM] Thinking-mode model produced reasoning but empty content/tool_calls, retrying...", routed_tier: response[:routed_tier])
           end
 
         rescue Faraday::TimeoutError => e
@@ -275,6 +283,11 @@ module Clacky
           Clacky::Shutdown.checkpoint!
           retries += 1
 
+          case e.routed_tier
+          when "floor"   then floor_fails += 1
+          when "upgrade" then upgrade_fails += 1
+          end
+
           # Probing failure: primary still down — renew cooling-off and retry with fallback.
           if @config.probing?
             handle_probe_failure
@@ -398,10 +411,21 @@ module Clacky
           raise
         end
 
+        # Fold this call's tier-attributed failures into the task-level tallies
+        # so later calls in the same task keep routing away from the failing
+        # lane — the per-call counters above reset to 0 once this call
+        # succeeds. A floor failure proves the floor lane is shaky for this
+        # task (route up); an upgrade failure proves the upgrade lane is shaky
+        # (route back down and stay on the floor until the task boundary).
+        @task_upstream_fails = (@task_upstream_fails || 0) + floor_fails if floor_fails > 0
+        @task_upgrade_fails = (@task_upgrade_fails || 0) + upgrade_fails if upgrade_fails > 0
+
         # Track cost and collect token usage data.
         # Pass the model name captured at API call time to ensure accurate billing
         # even if the user switched models during the (potentially long) API call.
-        token_data = track_cost(response[:usage], raw_api_usage: response[:raw_api_usage], model: api_call_model)
+        # For the "auto" alias the gateway reports the concrete model it routed
+        # to via X-Clacky-Routed-Model — bill under that so pricing resolves.
+        token_data = track_cost(response[:usage], raw_api_usage: response[:raw_api_usage], model: response[:routed_model] || api_call_model)
         response[:token_usage] = token_data
 
         # [DIAG] Log raw client response shape. Only emit when we see the
@@ -721,9 +745,11 @@ module Clacky
         # and the hint just sits in history without affecting behaviour.
         inject_upstream_truncation_hint_if_first(truncated)
 
-        raise Clacky::UpstreamTruncatedError,
+        raise Clacky::UpstreamTruncatedError.new(
           "[LLM] Upstream truncated tool_call `#{truncated[:name]}` " \
-          "(args=#{args_str[0, 40].inspect}). Retrying..."
+          "(args=#{args_str[0, 40].inspect}). Retrying...",
+          routed_tier: response[:routed_tier]
+        )
       end
 
       # True when a tool_call's arguments field is unusable — either empty

data/lib/clacky/agent/message_compressor_helper.rb

@@ -678,9 +678,8 @@ module Clacky
         lines
       end
 
-      # Serialize only the lightweight UI metadata needed to reconstruct file
-      # badges after compression. File paths, previews, sizes, MIME types, and
-      # contents deliberately stay out of the chunk archive.
+      # Serialize lightweight UI metadata for file badges after compression.
+      # Includes path/preview_path when set; file contents and sizes stay out of the archive.
       def display_files_for_archive(msg)
         files = Array(msg[:display_files]).dup
         Array(msg[:content]).each do |block|
@@ -688,12 +687,14 @@ module Clacky
           next unless %w[image image_url].include?((block[:type] || block["type"]).to_s)
 
           name = block[:image_name] || block["image_name"]
+          path = block[:image_path] || block["image_path"]
           if name.nil? || name.to_s.strip.empty?
-            path = block[:image_path] || block["image_path"]
             name = File.basename(path.to_s).sub(/\A[0-9a-f]{16}_/, "") unless path.to_s.empty?
           end
           name = "image" if name.nil? || name.to_s.strip.empty?
-          files << { name: name, type: "image" }
+          entry = { name: name, type: "image" }
+          entry[:path] = path.to_s unless path.nil? || path.to_s.strip.empty?
+          files << entry
         end
 
         files.filter_map do |file|
@@ -704,8 +705,13 @@ module Clacky
 
           type = file[:type] || file["type"] || "file"
           type = "file" if type.to_s.strip.empty?
-          { name: name.to_s, type: type.to_s }
-        end.uniq { |file| [file[:name], file[:type]] }
+          entry = { name: name.to_s, type: type.to_s }
+          path = file[:path] || file["path"]
+          entry[:path] = path.to_s unless path.nil? || path.to_s.strip.empty?
+          preview = file[:preview_path] || file["preview_path"]
+          entry[:preview_path] = preview.to_s unless preview.nil? || preview.to_s.strip.empty?
+          entry
+        end.uniq { |file| [file[:name], file[:type], file[:path]] }
       end
 
       # Once an image has a badge in the archive, omit the generic [image_url]

data/lib/clacky/agent/session_serializer.rb

@@ -576,7 +576,7 @@ module Clacky
 
       # Pull lightweight attachment badge metadata out of a chunk section.
       # The marker is internal archive data and must not appear in replayed text.
-      # Only name + type are accepted; paths and file contents are never restored.
+      # Restores name, type, and path/preview_path when present in the chunk marker.
       def extract_display_files_from_text(text)
         return [text, []] unless text.include?("_Display files:")
 
@@ -594,7 +594,12 @@ module Clacky
 
             type = file["type"] || file[:type] || "file"
             type = "file" if type.to_s.strip.empty?
-            files << { name: name.to_s, type: type.to_s }
+            entry = { name: name.to_s, type: type.to_s }
+            path = file["path"] || file[:path]
+            entry[:path] = path.to_s unless path.nil? || path.to_s.strip.empty?
+            preview = file["preview_path"] || file[:preview_path]
+            entry[:preview_path] = preview.to_s unless preview.nil? || preview.to_s.strip.empty?
+            files << entry
           end
           true
         end
@@ -750,6 +755,7 @@ module Clacky
                                          questions: questions)
               end
             else
+              remember_replayed_tool_name(tc[:id], name)
               ui.show_tool_call(name, args)
             end
           end
@@ -768,20 +774,65 @@ module Clacky
             msg[:content].each do |blk|
               next unless blk.is_a?(Hash) && blk[:type] == "tool_result"
 
-              ui.show_tool_result(blk[:content].to_s)
+              content = blk[:content].to_s
+              emit_replayed_tool_result(ui, content, blk[:tool_use_id])
             end
             replay_subagent_transcript(msg, ui)
           end
 
         when "tool"
           # OpenAI-format tool result
-          ui.show_tool_result(msg[:content].to_s)
+          emit_replayed_tool_result(ui, msg[:content].to_s, msg[:tool_call_id])
           replay_subagent_transcript(msg, ui)
         end
 
         replay_ext_events(msg, ui)
       end
 
+      # Tool results persist as the raw JSON the tool returned, so replay can
+      # rebuild the same structured `ui:` payload the live path sent instead of
+      # degrading the card to plain text (C-5797).
+      private def emit_replayed_tool_result(ui, content, tool_call_id)
+        ui_payload = replayed_tool_ui(content, tool_call_id)
+        if ui_payload
+          ui.show_tool_result(content, ui: ui_payload)
+        else
+          ui.show_tool_result(content)
+        end
+      end
+
+      # Tool names live on the preceding assistant message, so remember them by
+      # call id while walking the round.
+      private def remember_replayed_tool_name(call_id, name)
+        return if call_id.nil? || name.to_s.empty?
+
+        @replayed_tool_names ||= {}
+        @replayed_tool_names[call_id.to_s] = name
+      end
+
+      private def replayed_tool_ui(content, tool_call_id)
+        return nil if tool_call_id.nil?
+
+        name = (@replayed_tool_names || {})[tool_call_id.to_s]
+        return nil if name.nil?
+
+        text = content.to_s
+        return nil unless text.start_with?("{")
+
+        resolved = @tool_registry.resolve(name)
+        return nil if resolved.nil?
+
+        tool = @tool_registry.get(resolved)
+        return nil unless tool.respond_to?(:ui_result)
+
+        parsed = JSON.parse(text, symbolize_names: true)
+        return nil unless parsed.is_a?(Hash)
+
+        tool.ui_result(parsed)
+      rescue StandardError
+        nil
+      end
+
       # Re-emit custom extension events recorded on a message so extension
       # panels can rebuild their state after a page reload. Mirrors what
       # Agent#emit_event pushed live. No-op when the message carries none.