openclacky 1.5.4 → 1.5.6

data/lib/clacky/server/http_server.rb

@@ -217,6 +217,9 @@ module Clacky
         # Lazy: process-wide MCP registry. Created on first /api/mcp/:name access
         # so test setups that override Dir.home in before-hooks still work.
         @mcp_registry_mutex = Mutex.new
+        # Install jobs: job_id => { stage:, progress:, error:, done: }
+        @install_jobs       = {}
+        @install_jobs_mutex = Mutex.new
         # Access key authentication:
         # - localhost (127.0.0.1 / ::1) is always trusted; auth is skipped entirely.
         # - Any other bind address requires CLACKY_ACCESS_KEY env var.
@@ -370,10 +373,15 @@ module Clacky
 
         server.mount_proc("/") do |req, res|
           if req.path == "/" || req.path == "/index.html"
-            product_name = Clacky::BrandConfig.load.product_name || "OpenClacky"
+            brand        = Clacky::BrandConfig.load
+            product_name = brand.product_name || "OpenClacky"
+            logo_url     = brand.logo_url || "/logo_nav_dark.png"
+            logo_hidden  = logo_url.start_with?("http://", "https://") ? 'style="display:none"' : ""
             pure         = req.query["pure"] == "true"
             html = File.read(index_html_path)
                        .gsub("{{BRAND_NAME}}", product_name)
+                       .gsub("{{BRAND_LOGO_URL}}", logo_url)
+                       .gsub("{{BRAND_LOGO_HIDDEN}}", logo_hidden)
                        .gsub("{{EXT_SCRIPTS}}", pure ? "" : self.send(:webui_ext_script_tags))
             res.status                = 200
             res["Content-Type"]       = "text/html; charset=utf-8"
@@ -493,7 +501,9 @@ module Clacky
           # Building/extracting a tar.gz of ~/.clacky can take a while.
           120
         elsif path == "/api/store/extension/install"
-          300
+          10  # now async — just spawns a thread and returns job_id immediately
+        elsif path == "/api/store/extension/install/status"
+          10
         else
           30
         end
@@ -539,6 +549,9 @@ module Clacky
         when ["GET",    "/api/config/ocr"]    then api_get_ocr_config(res)
         when ["PATCH",  "/api/config/ocr"]    then api_update_ocr_config(req, res)
         when ["POST",   "/api/config/ocr/test"] then api_test_ocr_config(req, res)
+        when ["GET",    "/api/config/search"] then api_get_search_config(res)
+        when ["PATCH",  "/api/config/search"] then api_update_search_config(req, res)
+        when ["POST",   "/api/config/search/test"] then api_test_search_config(req, res)
         when ["POST",   "/api/internal/ocr-image"] then api_internal_ocr_image(req, res)
         when ["GET",    "/api/providers"]     then api_list_providers(res)
         when ["GET",    "/api/onboard/status"]    then api_onboard_status(res)
@@ -560,9 +573,11 @@ module Clacky
         when ["GET",    "/api/store/skills"]          then api_store_skills(res)
         when ["GET",    "/api/store/extensions"]          then api_store_extensions(req, res)
         when ["GET",    "/api/store/extensions/brand"]   then api_store_extensions_brand(res)
+        when ["GET",    "/api/store/extensions/system"]   then api_store_extensions_system(res)
         when ["GET",    "/api/store/extensions/installed"] then api_store_extensions_installed(res)
         when ["GET",    "/api/store/extension"]       then api_store_extension_detail(req, res)
         when ["POST",   "/api/store/extension/install"]  then api_store_extension_install(req, res)
+        when ["GET",    "/api/store/extension/install/status"] then api_store_extension_install_status(req, res)
         when ["POST",   "/api/store/extension/disable"] then api_store_extension_disable(req, res)
         when ["POST",   "/api/store/extension/enable"]  then api_store_extension_enable(req, res)
         when ["DELETE", "/api/store/extension"]         then api_store_extension_uninstall(req, res)
@@ -880,7 +895,7 @@ module Clacky
           @registry.with_session(session_id) { |s| agent = s[:agent] }
           if agent
             agent.project_id = project_id_override
-            @session_manager.save(agent.to_session_data)
+            @session_manager.save(agent.to_session_data(updated_at: Time.now))
           end
         end
 
@@ -2088,6 +2103,80 @@ module Clacky
         json_response(res, 200, { ok: false, message: e.message })
       end
 
+      # GET /api/config/search
+      # Lists installed searchers so the UI can offer whatever the user dropped
+      # into ~/.clacky/searchers/, not just the bundled ones.
+      def api_get_search_config(res)
+        config = Clacky::SearchConfig.load
+        json_response(res, 200, {
+          ok: true,
+          provider: config["provider"],
+          key_masked: config["key"].empty? ? nil : mask_api_key(config["key"]),
+          available: Clacky::Utils::SearcherManager.available
+        })
+      end
+
+      # PATCH /api/config/search
+      # Body: { provider: "tavily"|"", key?: "..." }
+      def api_update_search_config(req, res)
+        body = parse_json_body(req)
+        return json_response(res, 400, { error: "Invalid JSON" }) unless body
+
+        provider = body["provider"].to_s.strip
+        unless provider.empty? || Clacky::Utils::SearcherManager.path_for(provider)
+          return json_response(res, 422, { error: "Unknown search provider: #{provider}" })
+        end
+
+        key = body["key"].to_s
+        key = Clacky::SearchConfig.key if key.include?("****")
+
+        Clacky::SearchConfig.save(provider: provider, key: key)
+        json_response(res, 200, { ok: true, provider: provider })
+      rescue => e
+        json_response(res, 422, { error: e.message })
+      end
+
+      # POST /api/config/search/test
+      # Runs the searcher with a fixed query so the user gets a definitive
+      # answer before saving, rather than discovering a bad key mid-task.
+      def api_test_search_config(req, res)
+        body = parse_json_body(req) || {}
+        provider = body["provider"].to_s.strip
+        return json_response(res, 200, { ok: false, message: "provider is required" }) if provider.empty?
+
+        script = Clacky::Utils::SearcherManager.path_for(provider)
+        return json_response(res, 200, { ok: false, message: "searcher not found: #{provider}" }) unless script
+
+        key = body["key"].to_s
+        key = Clacky::SearchConfig.key if key.empty? || key.include?("****")
+
+        stdout, stderr, status = Clacky::Utils::ParserManager.capture3_with_timeout(
+          { "CLACKY_SEARCH_KEY" => key },
+          Clacky::Utils::SearcherManager.interpreter_for(script),
+          script, "openclacky", "1",
+          timeout: 30
+        )
+
+        if status == :timeout
+          return json_response(res, 200, { ok: false, message: "searcher timed out" })
+        end
+
+        unless status.success?
+          message = stderr.to_s.strip
+          return json_response(res, 200, { ok: false, message: message.empty? ? "searcher failed" : message })
+        end
+
+        count = begin
+          JSON.parse(stdout.to_s).size
+        rescue StandardError
+          return json_response(res, 200, { ok: false, message: "searcher did not output a JSON array" })
+        end
+
+        json_response(res, 200, { ok: true, message: "Returned #{count} result(s)" })
+      rescue => e
+        json_response(res, 200, { ok: false, message: e.message })
+      end
+
       # POST /api/internal/ocr-image
       # Internal endpoint used by parser scripts (e.g. pdf_parser_vlm.py) to
       # transcribe a single image via the configured OCR sidecar. Localhost-
@@ -2527,6 +2616,47 @@ module Clacky
         end
       end
 
+      # GET /api/store/extensions/system
+      #
+      # Returns only the builtin (system) extensions shipped with the gem.
+      def api_store_extensions_system(res)
+        result   = Clacky::ExtensionLoader.load_all
+        disabled = Clacky::ExtensionLoader.disabled_ids
+
+        hidden = %w[coding general ext-studio].to_set
+
+        extensions = Array(result&.containers).filter_map do |ext_id, container|
+          next unless container[:layer] == :builtin
+          next if hidden.include?(ext_id)
+
+          local_name   = container[:name].to_s.then { |n| n.empty? ? ext_id : n }
+          local_desc   = container.dig(:raw, "description").to_s
+          local_desc_zh = container.dig(:raw, "description_zh").to_s
+          local_author = container[:author].to_s
+          local_units  = units_from_container(container)
+          {
+            "id"              => ext_id,
+            "name"            => local_name,
+            "display_name"    => container.dig(:raw, "display_name") || local_name,
+            "display_name_zh" => container.dig(:raw, "display_name_zh"),
+            "slug"            => ext_id,
+            "version"         => container[:version],
+            "description"     => local_desc,
+            "description_zh"  => local_desc_zh,
+            "author"          => local_author,
+            "units"           => local_units,
+            "layer"           => "builtin",
+            "installed"       => true,
+            "removable"       => false,
+            "disabled"        => disabled.include?(ext_id),
+          }
+        end
+
+        json_response(res, 200, { ok: true, extensions: extensions })
+      rescue StandardError => e
+        json_response(res, 500, { ok: false, error: e.message })
+      end
+
       # GET /api/store/extensions/installed
       #
       # Returns all locally installed extensions (all layers: builtin, installed,
@@ -2656,6 +2786,7 @@ module Clacky
           slug = ext["name"] || ext[:name] || ext["slug"] || ext[:slug]
           container = extension_container(slug)
           ext  = ext.merge(
+            "slug"              => slug,
             "installed"         => !container.nil?,
             "installed_version" => container&.dig(:version),
             "removable"         => container && container[:layer] == :installed,
@@ -2732,7 +2863,9 @@ module Clacky
         json_response(res, 500, { ok: false, error: e.message })
       end
 
-      # DELETE /api/store/extension   body: { id: <slug> }
+      # POST /api/store/extension/install   body: { download_url:, name: }
+      # Starts an async install job and returns immediately with a job_id.
+      # Poll GET /api/store/extension/install/status?job_id=xxx for progress.
       def api_store_extension_install(req, res)
         body         = parse_json_body(req)
         download_url = body["download_url"].to_s.strip
@@ -2743,14 +2876,71 @@ module Clacky
           return
         end
 
-        Clacky::ExtensionPackager.install(download_url, force: true)
-        Clacky::ExtensionLoader.invalidate_cache!
-        Clacky::Telemetry.extension_install!(name) unless name.empty?
-        json_response(res, 200, { ok: true, name: name })
-      rescue Clacky::ExtensionPackager::Error => e
-        json_response(res, 422, { ok: false, error: e.message })
-      rescue StandardError => e
-        json_response(res, 500, { ok: false, error: e.message })
+        job_id = SecureRandom.hex(8)
+        @install_jobs_mutex.synchronize do
+          sweep_stale_install_jobs!
+          @install_jobs[job_id] = { stage: "downloading", progress: 0, error: nil, done: false, updated_at: Time.now }
+        end
+
+        Thread.new do
+          begin
+            on_progress = lambda do |info|
+              @install_jobs_mutex.synchronize do
+                @install_jobs[job_id] = info.merge(error: nil, done: false, updated_at: Time.now)
+              end
+            end
+            Clacky::ExtensionPackager.install(download_url, force: true, on_progress: on_progress)
+            Clacky::ExtensionLoader.invalidate_cache!
+            Clacky::Telemetry.extension_install!(name) unless name.empty?
+            @install_jobs_mutex.synchronize do
+              @install_jobs[job_id] = { stage: "done", progress: 100, error: nil, done: true, updated_at: Time.now }
+            end
+          rescue StandardError => e
+            @install_jobs_mutex.synchronize do
+              @install_jobs[job_id] = { stage: "error", progress: 0, error: e.message, done: true, updated_at: Time.now }
+            end
+          end
+        end
+
+        json_response(res, 200, { ok: true, job_id: job_id })
+      end
+
+      # GET /api/store/extension/install/status?job_id=xxx
+      def api_store_extension_install_status(req, res)
+        job_id = req.query["job_id"].to_s.strip
+        if job_id.empty?
+          json_response(res, 400, { ok: false, error: "Missing job_id." })
+          return
+        end
+        job = @install_jobs_mutex.synchronize do
+          sweep_stale_install_jobs!
+          @install_jobs[job_id]
+        end
+        if job.nil?
+          json_response(res, 404, { ok: false, error: "Job not found." })
+          return
+        end
+        # Clean up finished jobs after they are read as done
+        if job[:done]
+          @install_jobs_mutex.synchronize { @install_jobs.delete(job_id) }
+        end
+        json_response(res, 200, { ok: true }.merge(job))
+      end
+
+      # Install jobs can go stale in two ways:
+      #   - the client abandons the poll (tab closed, network drop) so a
+      #     finished job never gets picked up and deleted by the status endpoint
+      #   - the worker thread dies without ever updating the job hash (should
+      #     not happen given the rescue in api_store_extension_install, but a
+      #     hung Thread with no timeout upstream would otherwise pin memory
+      #     forever)
+      # Sweep anything past its TTL. Must be called from inside
+      # @install_jobs_mutex.synchronize.
+      INSTALL_JOB_TTL = 30 * 60 # seconds
+
+      private def sweep_stale_install_jobs!
+        cutoff = Time.now - INSTALL_JOB_TTL
+        @install_jobs.delete_if { |_id, job| (job[:updated_at] || Time.at(0)) < cutoff }
       end
 
       def api_store_extension_uninstall(req, res)
@@ -4354,12 +4544,30 @@ module Clacky
       # Each entry carries { id, title, title_zh, description, description_zh,
       # source, order, layer, author }. Extensions can supply title_zh /
       # description_zh / author in their ext.yml so the New Session cards read
-      # naturally and credit their author.
+      # naturally and credit their author. Third-party extension agents are
+      # ordered by most-recently-used (derived from session history) so the
+      # ones the user actually uses float to the front of that group.
       def api_list_agents(res)
-        agents = Clacky::AgentProfile.all
+        recency = agent_last_used_recency
+        agents = Clacky::AgentProfile.all(recency: recency)
         json_response(res, 200, { agents: agents })
       end
 
+      # Map agent_profile id => most recent session's updated_at (epoch seconds),
+      # scanning every session on disk. Used to rank extension agent cards by
+      # recent usage instead of a static declared `order`.
+      private def agent_last_used_recency
+        recency = {}
+        @session_manager.all_sessions.each do |s|
+          id = (s[:agent_profile] || "general").to_s
+          ts = s[:updated_at] || s[:created_at]
+          next unless ts
+          epoch = Time.parse(ts.to_s).to_i rescue next
+          recency[id] = epoch if epoch > (recency[id] || 0)
+        end
+        recency
+      end
+
       # GET /api/sessions/:id/skills — list user-invocable skills for a session,
       # filtered by the session's agent profile. Used by the frontend slash-command
       # autocomplete so only skills valid for the current profile are suggested.
@@ -4499,7 +4707,7 @@ module Clacky
         task_id = body["task_id"].to_i
         result = agent.switch_to_task(task_id)
         if result[:success]
-          @session_manager.save(agent.to_session_data(status: :success))
+          @session_manager.save(agent.to_session_data(status: :success, updated_at: Time.now))
           broadcast_session_update(session_id)
           json_response(res, 200, { ok: true, message: result[:message], task_id: result[:task_id] })
         else
@@ -5667,6 +5875,7 @@ module Clacky
         json_response(res, 200, {
           ok: true,
           enable_compression: @agent_config.enable_compression,
+          enable_idle_compression: @agent_config.enable_idle_compression,
           enable_prompt_caching: @agent_config.enable_prompt_caching,
           memory_update_enabled: @agent_config.memory_update_enabled,
           proxy_url: @agent_config.proxy_url.to_s,
@@ -5692,6 +5901,9 @@ module Clacky
         if body.key?("enable_compression")
           @agent_config.enable_compression = !!body["enable_compression"]
         end
+        if body.key?("enable_idle_compression")
+          @agent_config.enable_idle_compression = !!body["enable_idle_compression"]
+        end
         if body.key?("enable_prompt_caching")
           @agent_config.enable_prompt_caching = !!body["enable_prompt_caching"]
         end
@@ -6180,7 +6392,7 @@ module Clacky
         return json_response(res, 404, { error: "Session not found" }) unless agent
 
         agent.project_id = new_pid ? new_pid.to_s : nil
-        @session_manager.save(agent.to_session_data)
+        @session_manager.save(agent.to_session_data(updated_at: Time.now))
         broadcast_session_update(session_id)
 
         json_response(res, 200, { ok: true, project_id: agent.project_id })
@@ -6209,7 +6421,7 @@ module Clacky
         end
         
         # Save session data
-        @session_manager.save(agent.to_session_data)
+        @session_manager.save(agent.to_session_data(updated_at: Time.now))
         
         # Broadcast update event
         update_data = { type: "session_updated", session_id: session_id }
@@ -6253,7 +6465,7 @@ module Clacky
         end
 
         # Persist the change (saves to session file, NOT global config.yml)
-        @session_manager.save(agent.to_session_data)
+        @session_manager.save(agent.to_session_data(updated_at: Time.now))
 
         # Broadcast update to all clients
         broadcast_session_update(session_id)
@@ -6264,7 +6476,7 @@ module Clacky
       end
 
       # PATCH /api/sessions/:id/reasoning_effort
-      # Body: { "reasoning_effort": "off" | "low" | "medium" | "high" | "xhigh" }
+      # Body: { "reasoning_effort": "off" | "low" | "medium" | "high" | "xhigh" | "max" }
       def api_switch_session_reasoning_effort(session_id, req, res)
         body = parse_json_body(req)
         raw = body["reasoning_effort"]
@@ -6275,7 +6487,7 @@ module Clacky
         return json_response(res, 404, { error: "Session not found" }) unless agent
 
         agent.reasoning_effort = raw
-        @session_manager.save(agent.to_session_data)
+        @session_manager.save(agent.to_session_data(updated_at: Time.now))
         broadcast_session_update(session_id)
 
         json_response(res, 200, { ok: true, reasoning_effort: agent.reasoning_effort })
@@ -6318,7 +6530,7 @@ module Clacky
         end
 
         agent.set_session_sub_model(model_name)
-        @session_manager.save(agent.to_session_data)
+        @session_manager.save(agent.to_session_data(updated_at: Time.now))
         broadcast_session_update(session_id)
 
         json_response(res, 200, { ok: true, sub_model: agent.current_model_info[:sub_model] })
@@ -6442,7 +6654,7 @@ module Clacky
         agent.change_working_dir(expanded_dir)
         
         # Persist the change
-        @session_manager.save(agent.to_session_data)
+        @session_manager.save(agent.to_session_data(updated_at: Time.now))
         
         # Broadcast update to all clients
         broadcast_session_update(session_id)
@@ -6666,9 +6878,9 @@ module Clacky
 
         when "list_sessions"
           stats    = @registry.cron_stats
-          page     = @registry.list(limit: 16, exclude_type: "cron", exclude_project: true)
-          has_more = page.size > 15
-          all_sessions = page.first(15)
+          page     = @registry.list(limit: 11, exclude_type: "cron", exclude_project: true)
+          has_more = page.size > 10
+          all_sessions = page.first(10)
           projects = @project_manager.all
           # Include ALL sessions that belong to any project, regardless of the
           # 15-item pagination limit.  We merge them into the same `sessions`
@@ -6766,7 +6978,13 @@ module Clacky
         msg_created_at = Time.now.to_f
         web_ui = nil
         @registry.with_session(session_id) { |s| web_ui = s[:ui] }
-        web_ui&.show_user_message(content, created_at: msg_created_at, source: :web)
+        # Pass the uploaded files through to the realtime broadcast so images and
+        # attachments render in the bubble immediately. agent.run later appends the
+        # authoritative display_files to history — but only after vision/OCR
+        # processing finishes, which can take seconds. Without the preview here, a
+        # page refresh inside that window shows the message without its image (the
+        # "need to refresh several times before the image appears" bug).
+        web_ui&.show_user_message(content, created_at: msg_created_at, source: :web, files: Array(files))
 
         # File references are now handled inside agent.run — injected as a system_injected
         # message after the user message, so replay_history skips them automatically.
@@ -6877,7 +7095,7 @@ module Clacky
             Clacky::Logger.error("[shutdown] interrupt failed for session=#{id}: #{e.message}")
           end
           thread.join(2)
-          @session_manager.save(agent.to_session_data(status: :interrupted))
+          @session_manager.save(agent.to_session_data(status: :interrupted, updated_at: Time.now))
         end
       end
 
@@ -6934,7 +7152,7 @@ module Clacky
           # with the tab/window in the background — can still chime. Not part of
           # session history: a chime is a live cue, never replayed on refresh.
           broadcast_all(type: "task_finished", session_id: session_id)
-          @session_manager.save(agent.to_session_data(status: :success))
+          @session_manager.save(agent.to_session_data(status: :success, updated_at: Time.now))
           # Start idle compression timer now that the agent is idle
           idle_timer&.start
         rescue Clacky::AgentInterrupted
@@ -6943,7 +7161,7 @@ module Clacky
           next unless @registry.update_if_epoch(session_id, epoch, status: :idle)
           broadcast_session_update(session_id)
           broadcast(session_id, { type: "interrupted", session_id: session_id })
-          @session_manager.save(agent.to_session_data(status: :interrupted))
+          @session_manager.save(agent.to_session_data(status: :interrupted, updated_at: Time.now))
         rescue => e
           # Route error through web_ui so channel subscribers (飞书/企微) receive it too.
           web_ui = nil
@@ -6959,7 +7177,7 @@ module Clacky
           next unless @registry.update_if_epoch(session_id, epoch, status: :error, error: user_message, error_code: code, top_up_url: top_up_url, raw_message: raw_message)
           broadcast_session_update(session_id)
           web_ui&.show_error(user_message, code: code, top_up_url: top_up_url, raw_message: raw_message)
-          @session_manager.save(agent.to_session_data(status: :error, error_message: user_message, raw_message: raw_message))
+          @session_manager.save(agent.to_session_data(status: :error, error_message: user_message, raw_message: raw_message, updated_at: Time.now))
         end
         # Register the thread only if we still own the epoch; a faster
         # superseding task may have already replaced it.
@@ -7111,7 +7329,7 @@ module Clacky
 
         # Persist an initial snapshot so the session is immediately visible in registry.list
         # (which reads from disk). Without this, new sessions only appear after their first task.
-        @session_manager.save(agent.to_session_data)
+        @session_manager.save(agent.to_session_data(updated_at: Time.now))
 
         session_id
       end

data/lib/clacky/server/session_registry.rb

@@ -221,7 +221,8 @@ module Clacky
             latest_latency: s[:agent]&.latest_latency,
             card_model: model_info&.dig(:card_model),
             sub_model: model_info&.dig(:sub_model),
-            sub_model_options: sub_model_options_for(model_info) }
+            sub_model_options: sub_model_options_for(model_info),
+            todos: s[:agent]&.todos }
           end
         end
 
@@ -338,7 +339,12 @@ module Clacky
             latest_latency: s[:agent]&.latest_latency,
             card_model: model_info&.dig(:card_model),
             sub_model: model_info&.dig(:sub_model),
-            sub_model_options: sub_model_options_for(model_info) }
+            sub_model_options: sub_model_options_for(model_info),
+            # Live agent todos take precedence over the stale on-disk copy.
+            # On-disk todos are only persisted when agent.run finishes, so a
+            # snapshot taken mid-run (e.g. right after completing the last
+            # task) would otherwise still return the old list.
+            todos: s[:agent]&.todos }
         end
 
         build_enriched_row(disk, live)
@@ -379,6 +385,7 @@ module Clacky
           pinned:        s[:pinned] || false,
           channel_info:  s[:channel_info],
           project_id:    s[:project_id],
+          todos:         ls&.dig(:todos) || s[:todos] || [],
         }
       end
 
@@ -521,7 +528,7 @@ module Clacky
 
       private def persist_and_release(id, session)
         agent = session[:agent]
-        @session_manager&.save(agent.to_session_data(status: :success, preserve_updated_at: true)) if agent
+        @session_manager&.save(agent.to_session_data(status: :success)) if agent
 
         @mutex.synchronize do
           s = @sessions[id]

data/lib/clacky/server/web_ui_controller.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "cgi"
 require "json"
 require "securerandom"
 require_relative "../ui_interface"
@@ -70,11 +71,20 @@ module Clacky
         data[:created_at] = created_at if created_at
         # Build ev.images for the frontend renderer (history_user_message):
         #   - Images with data_url → pass the data_url directly (<img> thumbnail)
-        #   - Disk files (PDF, doc, etc., no data_url) → "pdf:name" sentinel (renders a badge)
+        #   - Disk image files (type=="image", has path) → /api/local-image proxy URL
+        #   - Disk files (PDF, doc, etc., no data_url, no image path) → "pdf:name" sentinel
         rendered = Array(files).filter_map do |f|
           url  = f[:data_url] || f["data_url"]
           name = f[:name]     || f["name"]
-          url || (name ? "pdf:#{name}" : nil)
+          type = f[:type]     || f["type"]
+          path = f[:path]     || f["path"]
+          if url
+            url
+          elsif type.to_s == "image" && path && File.exist?(path.to_s)
+            "/api/local-image?path=#{CGI.escape(path.to_s)}&v=#{File.mtime(path.to_s).to_i}"
+          elsif name
+            "pdf:#{name}"
+          end
         end
         data[:images] = rendered unless rendered.empty?
         emit("history_user_message", **data)

data/lib/clacky/session_manager.rb

@@ -36,6 +36,7 @@ module Clacky
       # Keep only the most recent 200 sessions (best-effort, never block save)
       begin
         cleanup_by_count(keep: 200, keep_cron: 200)
+        cleanup_trash(days: 8)
       rescue Exception # rubocop:disable Lint/RescueException
         # Cleanup is non-critical; swallow all errors (including AgentInterrupted)
       end

data/lib/clacky/tools/terminal.rb

@@ -480,9 +480,7 @@ module Clacky
           # leaves the result as invalid UTF-8. Re-scrub after truncation so
           # everything downstream (JSON.generate, format_result, UI) gets a
           # guaranteed-valid UTF-8 string.
-          preview = cleaned.byteslice(0, OVERFLOW_PREVIEW_CHARS)
-          preview.force_encoding(Encoding::UTF_8)
-          preview = preview.scrub("?") unless preview.valid_encoding?
+          preview = smart_truncate(cleaned, OVERFLOW_PREVIEW_CHARS)
 
           notice = if overflow_file
             "\n\n...[Output truncated for LLM: showing first #{OVERFLOW_PREVIEW_CHARS} " \
@@ -1429,6 +1427,35 @@ module Clacky
         nil
       end
 
+      # Smart truncation: keep head + tail within char budget.
+      # Ensures error messages at end of output remain visible.
+      private def smart_truncate(text, max_chars)
+        total_chars = text.bytesize
+        return text if total_chars <= max_chars
+
+        total_lines = text.lines.count
+
+        # 60% head, 40% tail
+        head_budget = (max_chars * 0.6).to_i
+        tail_budget = max_chars - head_budget
+
+        head = text.byteslice(0, head_budget)
+        head.force_encoding(Encoding::UTF_8)
+        head = head.scrub("?") unless head.valid_encoding?
+
+        tail = text.byteslice(-tail_budget, tail_budget)
+        tail.force_encoding(Encoding::UTF_8)
+        tail = tail.scrub("?") unless tail.valid_encoding?
+
+        # Align tail to line boundary if cut mid-line
+        if tail.include?("\n") && !tail.start_with?("\n")
+          first_nl = tail.index("\n")
+          tail = tail[(first_nl + 1)..-1] || ""
+        end
+
+        "#{head}\n\n...[#{total_lines} lines, #{total_chars} chars total, truncated]...\n\n#{tail}"
+      end
+
 
 
       # Max visible length of a command inside the tool-call summary line.