openclacky 1.5.14 → 1.5.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87ba4a4c52b1e52b0af0aad921bac4b8addd3d95955f44442894753ffd73ad14
-  data.tar.gz: 0a861cf43fcecc64275cb243029f7cc621ac32dfab949e0768aadfaf7e0f9490
+  metadata.gz: 9939ab09ac4e473dc7b096dac6a14c67f6d6060fe7678d7bd0b2635c7cc924ed
+  data.tar.gz: 9e0e566a77267f73388a9761d101672c86fd35513dc7248355a3c3df7d8017f6
 SHA512:
-  metadata.gz: 1b476b0c9ef80a39ac6830c35cac601abb5086d639d2806fc473af3a9074af25449f6f8befeea54bc07e38571e484f4012150d3a53adef674534f8b89ca8771e
-  data.tar.gz: 5ee52bb903109343a3a7adb9dc3681be836e22dd43f1b12021def3b32383c205b3750283b3af357f0e01b580ad1f5a8e2507c9f6133789b4813378e5a56120b3
+  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,91 @@ 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
+- Quote text selected in a message and send it as a reference badge
+- Queue messages while the agent is working, with pending-message controls in the CLI and Web UI (#561)
+- Steer a running turn with a queued message
+- Discover custom-endpoint models from the add-model dialog (#560 - @kylezhang)
+- Show vendor badges for each provider in the add-model dropdown
+- Label every model with its provider in the model picker
+- Open unviewable files in the system app and reveal them in the workspace tree
+- Follow the browsed directory in the directory picker sidebar
+- Show the extension and skill lists as segmented tabs in Extension Studio
+- Add disclosure carets to the clickable status-bar fields
+- Resolve redirected Windows shell folders in the WSL directory picker
+- Show web search results as UI results in the chat
+
+### Improved
+- Swap the extension and channel management order in the sidebar
+- Rename the Tasks sidebar entry to Scheduled Tasks
+- Improve mobile folder navigation in the directory picker (#549)
+- Improve the mobile layout of settings tabs and model controls (#548)
+- Add a global focus ring for keyboard navigation (#544)
+- Align the input behavior toggle with the send buttons
+- Deepen the directory-picker breadcrumb field
+- Keep the segmented control highlight dark on the dim and bluedark themes
+- Retire the dsk-deepseek-v4-flash model ids
+
+### Fixed
+- Keep the mobile composer above the soft keyboard (#557)
+- Install newly published brand skills when an agent starts
+- Show the marketplace takedown state instead of an unusable unpublish button
+- Show complete brand distribution for brand owners (#556)
+- Focus brand owners on brand publishing in Extension Studio (#555)
+- Hide the creator center from branded non-owners (#553)
+- Forward brand marketplace sorting to the backend (#552)
+- Complete the public session creation lifecycle (#551)
+- Make the @ mention menu selectable on the new-session page (#558)
+- Show a searched old session in the sidebar without a reload
+- Stop session updated_at from rolling back on save
+- Avoid a duplicated empty state in the sidebar search
+- Align reasoning and image fields with the Responses API schema
+- Use theme tokens for the badge colors
+- Give the calendar popup its own class namespace
+- Add the default user prompt for attachments
+
 ## [1.5.14] - 2026-09-10
 
 ### 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

@@ -18,6 +18,10 @@ module Clacky
         @name = session_data[:name] || ""
         @pinned = session_data[:pinned] || false
         @history = MessageHistory.new(session_data[:messages] || [])
+        @input_queue = (session_data[:pending_inputs] || []).map do |entry|
+          entry.reject { |key, _| key == :steer_target }.merge(delivery: "queue")
+        end
+        @accepting_steering = false
         @todos = session_data[:todos] || []  # Restore todos from session
         @iterations = session_data.dig(:stats, :total_iterations) || 0
         @total_cost = session_data.dig(:stats, :total_cost_usd) || 0.0
@@ -227,15 +231,25 @@ module Clacky
         stats_data[:last_error]     = error_message if status == :error && error_message
         stats_data[:last_error_raw] = raw_message   if status == :error && raw_message
 
+        # Saves that carry no user-visible activity (idle compression, channel
+        # bookkeeping) pass no timestamp and reuse the last one this agent
+        # wrote. Keeping it in memory rather than falling back to the value
+        # loaded at restore time is what stops those saves from dragging an
+        # actively used session back to the moment it was restored.
+        stamp = updated_at || @persisted_updated_at || Time.now
+        stamp = stamp.iso8601 if stamp.respond_to?(:iso8601)
+        @persisted_updated_at = stamp
+
         {
           session_id: @session_id,
           name: @name,
           pinned: @pinned,
           created_at: @created_at,
-          updated_at: (updated_at || @persisted_updated_at || Time.now.iso8601).then { |v| v.is_a?(String) ? v : v.iso8601 },
+          updated_at: stamp,
           working_dir: @working_dir,
           source: @source.to_s,                      # "manual" | "cron" | "channel" | "setup"
           agent_profile: @agent_profile&.name || "", # "general" | "coding" | custom
+          pending_inputs: pending_inputs,
           todos: @todos,  # Include todos in session data
           time_machine: {  # Include Time Machine state
             task_parents: @task_parents || {},
@@ -562,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:")
 
@@ -580,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
@@ -736,6 +755,7 @@ module Clacky
                                          questions: questions)
               end
             else
+              remember_replayed_tool_name(tc[:id], name)
               ui.show_tool_call(name, args)
             end
           end
@@ -754,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.