openclacky 0.9.23 → 0.9.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1add81a8b60017ed8ed70e090af57bd68d0dce5670124fab1c13b878e57d21d
-  data.tar.gz: 1607062100acf56326e62d75a2fa0599d4eee61686785fceed1e16578c025c6c
+  metadata.gz: 5338bcdeaf4b2aafed416365f56467a99a6107911b24df2bfe9d94d757d03528
+  data.tar.gz: 8e06f6ca6b0d5a0a9c70ab758fc13b2f84d755f7d61e30a9708fdadd4db82309
 SHA512:
-  metadata.gz: 3d499b6484f327b0cdcdaaba21019c9a5b314ba73910c03fde7d64be880e365dea1d1a5bd82cdf993647b11e5b749cd667567265897b99d4e5f98678651ea464
-  data.tar.gz: f02f3b6317c4971152d055a4b6861d53bf719e8278bc65dd3031a80f718937f93c92add6b589b3c3396589e85d1dca4cf1100a440c65691352b0ab4e273c7f43
+  metadata.gz: 7862cd557ea5ba9e88184b314fd88fc820d1f4e0c5a9bbebbfcdee75f33301876aff7df7f13cf07eaa21c7fb47d0efa65e7f051c1641ced6c20d1142e9e52819
+  data.tar.gz: b33e3cc3331e70328d366a38b67e472c760eb6bbe4b5621532ee4ae60585303d9042c4953f29f31e4256f357765d8aafee2b3e69fa87f31c386f9310be790c46

data/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.24] - 2026-04-02
+
+### Added
+- **New session list & search in Web UI**: sidebar now shows full session history with real-time search — find any past conversation instantly
+- **Session type indicators**: sessions are labeled by type (chat / agent) so you can see at a glance what kind of interaction it was
+- **Image lightbox**: click any image in the chat to expand it full-screen with a clean overlay viewer
+- **Session history replay for streaming messages**: chunk-based (streaming) messages are now fully replayed when revisiting a past session
+- **Xiaomi AI provider**: added Xiaomi as a supported AI provider
+- **Chinese Bing web search**: web search now uses cn.bing.com for users in China, improving search relevance and reliability
+- **Auto-install system dependencies script**: agent can now automatically install missing system packages (Node, Python, etc.) via a bundled `install_system_deps.sh` script
+- **User message timestamps**: each user message now displays the time it was sent
+
+### Fixed
+- **Bedrock file attachments & partial cost tracking**: fixed file handling and cost accumulation for AWS Bedrock sessions
+- **Session name timestamp**: fixed incorrect timestamp display on session names
+- **New session scroll**: new sessions now correctly scroll to the latest message
+- **Feishu WebSocket client crash**: fixed a nil-reference error that caused the Feishu WS client to crash on reconnect
+
 ## [0.9.23] - 2026-04-01
 
 ### Improved
@@ -17,7 +35,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **CLI -c option model initialization**: fixed a bug where the CLI command with -c option was not passing the model name to the client, causing routing failures for certain providers
 
 ### More
-- Rename provider display name to "ClackyAI" for consistency
+- ClackyAI provider updated to use the latest model name format (abs- prefix)
 
 ## [0.9.22] - 2026-03-31
 

data/lib/clacky/agent/message_compressor_helper.rb

@@ -305,9 +305,11 @@ module Clacky
         return nil unless @session_id && @created_at
 
         # Messages being compressed = original minus system message minus recent messages
+        # Also exclude system-injected scaffolding (session context, memory prompts, etc.)
+        # — these are internal CLI metadata and must not appear in chunk MD or WebUI history.
         recent_set = recent_messages.to_a
         messages_to_archive = original_messages.reject do |m|
-          m[:role] == "system" || recent_set.include?(m)
+          m[:role] == "system" || m[:system_injected] || recent_set.include?(m)
         end
 
         return nil if messages_to_archive.empty?
@@ -374,9 +376,23 @@ module Clacky
             end
             lines << ""
             # Include tool calls summary if present
+            # Format: "_Tool calls: name | {args_json}_" so replay can restore args for WebUI display.
             if msg[:tool_calls]&.any?
-              tool_names = msg[:tool_calls].map { |tc| tc.dig(:function, :name) }.compact.join(", ")
-              lines << "_Tool calls: #{tool_names}_"
+              tc_parts = msg[:tool_calls].map do |tc|
+                name = tc.dig(:function, :name) || tc[:name] || ""
+                next nil if name.empty?
+
+                args_raw = tc.dig(:function, :arguments) || tc[:arguments] || {}
+                args = args_raw.is_a?(String) ? (JSON.parse(args_raw) rescue nil) : args_raw
+                if args.is_a?(Hash) && !args.empty?
+                  # Truncate large string values to keep chunk MD readable
+                  compact = args.transform_values { |v| v.is_a?(String) && v.length > 200 ? v[0..197] + "..." : v }
+                  "#{name} | #{compact.to_json}"
+                else
+                  name
+                end
+              end.compact
+              lines << "_Tool calls: #{tc_parts.join("; ")}_"
               lines << ""
             end
             lines << format_message_content(content) if content

data/lib/clacky/agent/session_serializer.rb

@@ -114,6 +114,7 @@ module Clacky
       # Replay conversation history by calling ui.show_* methods for each message.
       # Supports cursor-based pagination using created_at timestamps on user messages.
       # Each "round" starts at a user message and includes all subsequent assistant/tool messages.
+      # Compressed chunks (chunk_path on assistant messages) are transparently expanded.
       #
       # @param ui [Object] UI interface that responds to show_user_message, show_assistant_message, etc.
       # @param limit [Integer] Maximum number of rounds (user turns) to replay
@@ -147,9 +148,19 @@ module Clacky
             rounds << current_round
           elsif current_round
             current_round[:events] << msg
+          elsif msg[:compressed_summary] && msg[:chunk_path]
+            # Compressed summary sitting before any user rounds — expand it from chunk md
+            chunk_rounds = parse_chunk_md_to_rounds(msg[:chunk_path])
+            rounds.concat(chunk_rounds)
           end
         end
 
+        # Expand any compressed_summary assistant messages sitting inside a round's events.
+        # These occur when compression happened mid-round (rare) — expand them in-place.
+        rounds.each do |round|
+          round[:events].select! { |ev| !ev[:compressed_summary] }
+        end
+
         # Apply before-cursor filter: only rounds whose user message created_at < before
         if before
           rounds = rounds.select { |r| r[:user_msg][:created_at] && r[:user_msg][:created_at] < before }
@@ -193,6 +204,159 @@ module Clacky
         { has_more: has_more }
       end
 
+      # Parse a chunk MD file into an array of rounds compatible with replay_history.
+      # Each round is { user_msg: Hash, events: Array<Hash> }.
+      # Timestamps are synthesised from the chunk's archived_at, spread backwards.
+      # Recursively expands nested chunk references (compressed summary inside a chunk).
+      #
+      # @param chunk_path [String] Path to the chunk md file
+      # @return [Array<Hash>] rounds array (may be empty if file missing/unreadable)
+      private def parse_chunk_md_to_rounds(chunk_path)
+        return [] unless chunk_path && File.exist?(chunk_path.to_s)
+
+        raw = File.read(chunk_path.to_s, encoding: "utf-8")
+
+        # Parse YAML front matter to get archived_at for synthetic timestamps
+        archived_at = nil
+        if raw.start_with?("---")
+          fm_end = raw.index("\n---\n", 4)
+          if fm_end
+            fm_text = raw[4...fm_end]
+            fm_text.each_line do |line|
+              if line.start_with?("archived_at:")
+                archived_at = Time.parse(line.split(":", 2).last.strip) rescue nil
+              end
+            end
+          end
+        end
+        base_time = (archived_at || Time.now).to_f
+        chunk_dir = File.dirname(chunk_path.to_s)
+
+        # Split into sections by ## headings
+        sections = []
+        current_role       = nil
+        current_lines      = []
+        current_nested_chunk = nil  # chunk reference from a Compressed Summary heading
+
+        raw.each_line do |line|
+          stripped = line.chomp
+          if (m = stripped.match(/\A## Assistant \[Compressed Summary — original conversation at: (.+)\]/))
+            # Nested chunk reference — record it, treat as assistant section
+            sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk } if current_role
+            current_role         = "assistant"
+            current_lines        = []
+            current_nested_chunk = File.join(chunk_dir, m[1])
+          elsif stripped.match?(/\A## (User|Assistant)/)
+            sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk } if current_role
+            current_role         = stripped.match(/\A## (User|Assistant)/)[1].downcase
+            current_lines        = []
+            current_nested_chunk = nil
+          elsif stripped.match?(/\A### Tool Result:/)
+            sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk } if current_role
+            current_role         = "tool"
+            current_lines        = []
+            current_nested_chunk = nil
+          else
+            current_lines << line
+          end
+        end
+        sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk } if current_role
+
+        # Remove front-matter / header noise sections (nil role or non-user/assistant/tool)
+        sections.select! { |s| %w[user assistant tool].include?(s[:role]) }
+
+        # Group into rounds: each user section starts a new round
+        rounds        = []
+        current_round = nil
+        round_index   = 0
+
+        sections.each do |sec|
+          text = sec[:lines].join.strip
+
+          # Nested chunk: expand it recursively, prepend before current rounds
+          if sec[:nested_chunk]
+            nested = parse_chunk_md_to_rounds(sec[:nested_chunk])
+            rounds = nested + rounds unless nested.empty?
+            # Also render its summary text as an assistant event in current round if any
+            if current_round && !text.empty?
+              current_round[:events] << { role: "assistant", content: text }
+            end
+            next
+          end
+
+          next if text.empty?
+
+          if sec[:role] == "user"
+            round_index += 1
+            # Synthetic timestamp: spread rounds backwards from archived_at
+            synthetic_ts = base_time - (sections.size - round_index) * 1.0
+            current_round = {
+              user_msg: {
+                role: "user",
+                content: text,
+                created_at: synthetic_ts,
+                _from_chunk: true
+              },
+              events: []
+            }
+            rounds << current_round
+          elsif current_round
+            if sec[:role] == "assistant"
+              # Detect "_Tool calls: ..._" lines — convert to tool_calls events
+              # so _replay_single_message renders them as tool group UI (same as live).
+              #
+              # Formats supported:
+              #   New: "_Tool calls: name | {"arg":"val"}; name2 | {"k":"v"}_"
+              #   Old: "_Tool calls: name1, name2_"  (backward compat)
+              remaining_lines = []
+              pending_tool_entries = []  # [{name:, args:}]
+
+              text.each_line do |line|
+                stripped = line.strip
+                if (m = stripped.match(/\A_Tool calls?:\s*(.+?)_?\z/i))
+                  raw = m[1]
+                  # New format uses ";" as separator between tools (each entry: "name | {json}")
+                  # Old format uses "," with no JSON part.
+                  entries = raw.include?(" | ") ? raw.split(/;\s*/) : raw.split(/,\s*/)
+                  entries.each do |entry|
+                    entry = entry.strip
+                    if (parts = entry.match(/\A(.+?)\s*\|\s*(\{.+\})\z/))
+                      tool_name = parts[1].strip
+                      args = JSON.parse(parts[2]) rescue {}
+                      pending_tool_entries << { name: tool_name, args: args }
+                    else
+                      pending_tool_entries << { name: entry, args: {} }
+                    end
+                  end
+                else
+                  remaining_lines << line
+                end
+              end
+
+              # Flush any plain text
+              plain_text = remaining_lines.join.strip
+              current_round[:events] << { role: "assistant", content: plain_text } unless plain_text.empty?
+
+              # Emit one synthetic tool_calls message per detected tool
+              pending_tool_entries.each do |entry|
+                current_round[:events] << {
+                  role: "assistant",
+                  content: "",
+                  tool_calls: [{ name: entry[:name], arguments: entry[:args] }]
+                }
+              end
+            else
+              current_round[:events] << { role: "tool", content: text }
+            end
+          end
+        end
+
+        rounds
+      rescue => e
+        Clacky::Logger.warn("parse_chunk_md_to_rounds failed for #{chunk_path}: #{e.message}")
+        []
+      end
+
 
       # Render a single non-user message into the UI.
       # Used by both the normal round-based replay and the compressed-session fallback.
@@ -328,12 +492,14 @@ module Clacky
           next unless block[:type] == "image_url"
 
           url = block.dig(:image_url, :url)
-          next unless url && url.start_with?("data:")
+          # image_path is stored at send-time so replay can reconstruct the image from tmp
+          path = block[:image_path]
+
+          next unless url&.start_with?("data:") || path
 
-          # Derive mime_type from the data URL prefix (e.g. "data:image/jpeg;base64,...")
-          mime_type = url[/\Adata:([^;]+);/, 1] || "image/jpeg"
+          mime_type = (url || "")[/\Adata:([^;]+);/, 1] || "image/jpeg"
           ext       = mime_type.split("/").last
-          { name: "image_#{idx + 1}.#{ext}", mime_type: mime_type, data_url: url }
+          { name: "image_#{idx + 1}.#{ext}", mime_type: mime_type, data_url: url, path: path }
         end
       end
     end

data/lib/clacky/agent.rb

@@ -218,7 +218,9 @@ module Clacky
       all_disk_files = disk_files + downgraded
 
       # Format user message — text + inline vision images
-      user_content = format_user_content(user_input, vision_images.map { |v| v[:url] })
+      # Store the tmp path alongside the data_url so the history replay can
+      # reconstruct the image if the base64 was stripped (e.g. after compression).
+      user_content = format_user_content(user_input, vision_images.map { |v| { url: v[:url], path: v[:path] } })
 
       # Parse disk files — agent's responsibility, not the upload layer.
       # process_path runs the parser script and returns a FileRef with preview_path or parse_error.
@@ -1111,15 +1113,25 @@ module Clacky
 
     # Build user message content for LLM.
     # Returns plain String when no vision images; Array of content parts otherwise.
-    private def format_user_content(text, vision_urls)
-      vision_urls ||= []
+    # Build user message content for LLM.
+    # vision_images: Array of String (plain url) OR Hash { url:, path: }
+    # path is stored in the block so history replay can reconstruct the image
+    # from the tmp file when the base64 data_url is no longer available.
+    private def format_user_content(text, vision_images)
+      vision_images ||= []
 
-      return text if vision_urls.empty?
+      return text if vision_images.empty?
 
       content = []
       content << { type: "text", text: text } unless text.nil? || text.empty?
-      vision_urls.each do |url|
-        content << { type: "image_url", image_url: { url: url } }
+      vision_images.each do |img|
+        if img.is_a?(Hash)
+          block = { type: "image_url", image_url: { url: img[:url] } }
+          block[:image_path] = img[:path] if img[:path]
+          content << block
+        else
+          content << { type: "image_url", image_url: { url: img } }
+        end
       end
       content
     end
@@ -1156,7 +1168,8 @@ module Clacky
         "Today is #{Time.now.strftime('%Y-%m-%d, %A')}",
         "Current model: #{current_model}",
         os != :unknown ? "OS: #{Clacky::Utils::EnvironmentDetector.os_label}" : nil,
-        desktop ? "Desktop: #{desktop}" : nil
+        desktop ? "Desktop: #{desktop}" : nil,
+        "Working directory: #{@working_dir}"
       ].compact.join(". ")
 
       content = "[Session context: #{parts}]"

data/lib/clacky/message_format/anthropic.rb

@@ -168,6 +168,8 @@ module Clacky
         #      user message as a cache breakpoint, which invalidates the intended cache boundary
         #      and results in cache misses (cache_read=0) every turn.
         blocks = content_to_blocks(content)
+        # Anthropic rejects messages with an empty content array — use a placeholder text block.
+        blocks = [{ type: "text", text: "..." }] if blocks.empty?
         { role: role, content: blocks }
       end
 
@@ -176,11 +178,17 @@ module Clacky
       private_class_method def self.content_to_blocks(content)
         case content
         when String
+          # Anthropic rejects blank text blocks — skip empty strings
+          return [] if content.empty?
+
           [{ type: "text", text: content }]
         when Array
           content.map { |b| normalize_block(b) }.compact
         else
-          [{ type: "text", text: content.to_s }]
+          str = content.to_s
+          return [] if str.empty?
+
+          [{ type: "text", text: str }]
         end
       end
 
@@ -190,8 +198,12 @@ module Clacky
 
         case block[:type]
         when "text"
+          # Anthropic rejects blank text blocks — drop them instead of sending { type:"text", text:"" }
+          text = block[:text]
+          return nil if text.nil? || text.empty?
+
           # Preserve cache_control if present (placed by Client#apply_message_caching)
-          result = { type: "text", text: block[:text] }
+          result = { type: "text", text: text }
           result[:cache_control] = block[:cache_control] if block[:cache_control]
           result
         when "image_url"

data/lib/clacky/message_format/bedrock.rb

@@ -180,6 +180,8 @@ module Clacky
 
         # regular user/assistant message
         blocks = content_to_blocks(content)
+        # Bedrock rejects messages with an empty content array — use a placeholder text block.
+        blocks = [{ text: "..." }] if blocks.empty?
         { role: role, content: blocks }
       end
 
@@ -187,11 +189,17 @@ module Clacky
       private_class_method def self.content_to_blocks(content)
         case content
         when String
+          # Bedrock rejects blank text blocks — skip empty strings
+          return [] if content.empty?
+
           [{ text: content }]
         when Array
           content.map { |b| normalize_block(b) }.compact
         else
-          [{ text: content.to_s }]
+          str = content.to_s
+          return [] if str.empty?
+
+          [{ text: str }]
         end
       end
 
@@ -201,7 +209,11 @@ module Clacky
 
         case block[:type]
         when "text"
-          { text: block[:text].to_s }
+          # Bedrock rejects blank text blocks — drop them
+          text = block[:text].to_s
+          return nil if text.empty?
+
+          { text: text }
         when "image_url"
           # Bedrock image format — base64 only
           url = block.dig(:image_url, :url) || block[:url]

data/lib/clacky/providers.rb

@@ -59,6 +59,15 @@ module Clacky
           "abs-claude-haiku-4-5"
         ],
         "website_url" => "https://clacky.ai"
+      }.freeze,
+
+      "mimo" => {
+        "name" => "MiMo (Xiaomi)",
+        "base_url" => "https://api.xiaomimimo.com/v1",
+        "api" => "openai-completions",
+        "default_model" => "mimo-v2-pro",
+        "models" => ["mimo-v2-pro", "mimo-v2-omni"],
+        "website_url" => "https://platform.xiaomimimo.com/"
       }.freeze
 
     }.freeze

data/lib/clacky/server/channel/adapters/feishu/ws_client.rb

@@ -160,6 +160,12 @@ module Clacky
             @ping_interval = (client_config["PingInterval"] || 90).to_i
 
             url = data.dig("data", "URL")
+            if url.nil? || url.strip.empty?
+              Clacky::Logger.error("[feishu-ws] WebSocket endpoint URL is missing from response. " \
+                                   "Please verify your Feishu App ID and App Secret are correct.")
+              raise "Failed to get WebSocket endpoint: URL is missing (check your Feishu App ID / App Secret)"
+            end
+
             if url =~ /service_id=(\d+)/
               @service_id = $1.to_i
             end

data/lib/clacky/server/http_server.rb

@@ -34,7 +34,18 @@ module Clacky
         rendered = Array(files).filter_map do |f|
           url  = f[:data_url] || f["data_url"]
           name = f[:name]     || f["name"]
-          url || (name ? "pdf:#{name}" : nil)
+          path = f[:path]     || f["path"]
+
+          if url
+            url
+          elsif path && File.exist?(path.to_s)
+            # Reconstruct data_url from the tmp file (still present on disk)
+            Utils::FileProcessor.image_path_to_data_url(path) rescue "expired:#{name}"
+          elsif name
+            # File badge for non-image disk files, or image whose tmp file is gone
+            type = f[:type] || f["type"] || ""
+            type.to_s == "image" ? "expired:#{name}" : "pdf:#{name}"
+          end
         end
         ev[:images] = rendered unless rendered.empty?
         @events << ev
@@ -393,12 +404,16 @@ module Clacky
 
       def api_list_sessions(req, res)
         query   = URI.decode_www_form(req.query_string.to_s).to_h
-        limit   = [query["limit"].to_i.then { |n| n > 0 ? n : 10 }, 50].min
-        before  = query["before"].to_s.strip.then { |v| v.empty? ? nil : v }
-        source  = query["source"].to_s.strip.then { |v| v.empty? ? nil : v }
-        profile = query["profile"].to_s.strip.then { |v| v.empty? ? nil : v }
+        limit   = [query["limit"].to_i.then { |n| n > 0 ? n : 20 }, 50].min
+        before  = query["before"].to_s.strip.then  { |v| v.empty? ? nil : v }
+        q       = query["q"].to_s.strip.then       { |v| v.empty? ? nil : v }
+        date    = query["date"].to_s.strip.then    { |v| v.empty? ? nil : v }
+        type    = query["type"].to_s.strip.then    { |v| v.empty? ? nil : v }
+        # Backward-compat: ?source=<x> and ?profile=coding → type
+        type ||= query["profile"].to_s.strip.then { |v| v.empty? ? nil : v }
+        type ||= query["source"].to_s.strip.then  { |v| v.empty? ? nil : v }
         # Fetch one extra to detect has_more without a separate count query
-        sessions = @registry.list(limit: limit + 1, before: before, source: source, profile: profile)
+        sessions = @registry.list(limit: limit + 1, before: before, q: q, date: date, type: type)
         has_more = sessions.size > limit
         sessions = sessions.first(limit)
         json_response(res, 200, { sessions: sessions, has_more: has_more })
@@ -1774,24 +1789,12 @@ module Clacky
           interrupt_session(session_id)
 
         when "list_sessions"
-          # Initial load: 5 per bucket so all tabs/sections get their first page.
-          # General area tabs: manual / cron / channel / setup — filtered by source.
-          # Coding section: profile=coding — source is irrelevant (no source filter).
-          # has_more_by_source drives independent load-more buttons on the frontend.
-          buckets = {
-            "manual"  => { source: "manual",  profile: "general" },
-            "cron"    => { source: "cron",    profile: "general" },
-            "channel" => { source: "channel", profile: "general" },
-            "setup"   => { source: "setup",   profile: "general" },
-            "coding"  => { profile: "coding" },
-          }
-          by_bucket = buckets.each_with_object({}) do |(key, params), h|
-            page = @registry.list(limit: 6, **params)  # +1 to detect has_more
-            h[key] = { sessions: page.first(5), has_more: page.size > 5 }
-          end
-          all_sessions = by_bucket.values.flat_map { |v| v[:sessions] }.uniq { |s| s[:id] }
-          has_more_map = by_bucket.transform_values { |v| v[:has_more] }
-          conn.send_json(type: "session_list", sessions: all_sessions, has_more_by_source: has_more_map)
+          # Initial load: newest 20 sessions regardless of source/profile.
+          # Single unified query — frontend shows all in one time-sorted list.
+          page = @registry.list(limit: 21)
+          has_more = page.size > 20
+          all_sessions = page.first(20)
+          conn.send_json(type: "session_list", sessions: all_sessions, has_more: has_more)
 
         when "run_task"
           # Client sends this after subscribing to guarantee it's ready to receive

data/lib/clacky/server/session_registry.rb

@@ -145,24 +145,40 @@ module Clacky
       #   before:  ISO8601 cursor — only sessions with created_at < before
       #
       # source and profile are orthogonal — either can be nil independently.
-      def list(limit: nil, before: nil, source: nil, profile: nil)
+      def list(limit: nil, before: nil, q: nil, date: nil, type: nil)
         return [] unless @session_manager
 
         live = @mutex.synchronize do
           @sessions.transform_values do |s|
             model_info = s[:agent]&.current_model_info
-            { status: s[:status], error: s[:error], model: model_info&.dig(:model) }
+            live_name  = s[:agent]&.name
+            live_name  = nil if live_name&.empty?
+            { status: s[:status], error: s[:error], model: model_info&.dig(:model), name: live_name,
+              total_tasks: s[:agent]&.total_tasks, total_cost: s[:agent]&.total_cost }
           end
         end
 
         all = @session_manager.all_sessions  # already sorted newest-first
 
-        # ── source filter ────────────────────────────────────────────────────
-        all = all.select { |s| s_source(s) == source } if source
-        # source == nil → no filter, return all
+        # ── type filter (replaces old source/profile split) ──────────────────
+        # type=coding  → agent_profile == "coding"
+        # type=manual/cron/channel/setup → source match (profile=general implied)
+        if type
+          if type == "coding"
+            all = all.select { |s| (s[:agent_profile] || "general").to_s == "coding" }
+          else
+            all = all.select { |s| s_source(s) == type && (s[:agent_profile] || "general").to_s != "coding" }
+          end
+        end
 
-        # ── profile filter ───────────────────────────────────────────────────
-        all = all.select { |s| (s[:agent_profile] || "general").to_s == profile } if profile
+        # ── date filter (YYYY-MM-DD, matches created_at prefix) ──────────────
+        all = all.select { |s| s[:created_at].to_s.start_with?(date) } if date
+
+        # ── name search ──────────────────────────────────────────────────────
+        if q && !q.empty?
+          q_down = q.downcase
+          all = all.select { |s| (s[:name] || "").downcase.include?(q_down) }
+        end
 
         all = all.select { |s| (s[:created_at] || "") < before } if before
         all = all.first(limit) if limit
@@ -172,7 +188,7 @@ module Clacky
           ls = live[id]
           {
             id:            id,
-            name:          s[:name] || "",
+            name:          ls&.dig(:name) || s[:name] || "",
             status:        ls ? ls[:status].to_s : "idle",
             error:         ls ? ls[:error] : nil,
             model:         ls&.dig(:model),
@@ -181,8 +197,8 @@ module Clacky
             working_dir:   s[:working_dir],
             created_at:    s[:created_at],
             updated_at:    s[:updated_at],
-            total_tasks:   s.dig(:stats, :total_tasks) || 0,
-            total_cost:    s.dig(:stats, :total_cost_usd) || 0.0,
+            total_tasks:   ls&.dig(:total_tasks) || s.dig(:stats, :total_tasks) || 0,
+            total_cost:    ls&.dig(:total_cost)  || s.dig(:stats, :total_cost_usd) || 0.0,
           }
         end
       end

data/lib/clacky/tools/safe_shell.rb

@@ -61,6 +61,15 @@ module Clacky
           # 4. Call parent class execution method
           result = super(command: safe_command, soft_timeout: soft_timeout, hard_timeout: hard_timeout, max_output_lines: max_output_lines, output_buffer: output_buffer, working_dir: working_dir)
 
+          # 4a. If macOS xcode-select shim detected, replace stderr with actionable message
+          if xcode_tools_missing?(result[:stderr])
+            result = result.merge(
+              stderr: "Xcode Command Line Tools are not installed.\nRun: bash ~/.clacky/scripts/install_system_deps.sh\nThen retry the original command.",
+              exit_code: 1,
+              success: false
+            )
+          end
+
           # 5. Enhance result information
           enhance_result(result, command, safe_command, safety_replacer)
 
@@ -294,6 +303,14 @@ module Clacky
         return text if text.length <= max_length
         "#{text[0...max_length-3]}..."
       end
+
+      # Returns true if stderr contains the macOS xcode-select shim message,
+      # which appears when Xcode Command Line Tools are not installed and the
+      # user (or LLM) tries to run python3, git, make, gcc, etc.
+      def xcode_tools_missing?(stderr)
+        return false if stderr.nil? || stderr.empty?
+        stderr.include?("xcode-select") && stderr.include?("No developer tools were found")
+      end
     end
 
     class CommandSafetyReplacer