openclacky 1.5.19 → 1.5.21

data/lib/clacky/server/discover.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require "tmpdir"
+require_relative "pid_files"
 require "socket"
 
 module Clacky
   module Server
     # Discover locally-running Clacky server(s) by scanning PID files
-    # written by Master at /tmp/clacky-master-<port>.pid.
+    # written by Master in the configured PID directory.
     #
     # Used by the CLI (bare `clacky agent` mode) to auto-detect a sibling
     # server process, so skills that call back into the server (channels,
@@ -17,7 +17,6 @@ module Clacky
     # Does NOT probe the TCP port (avoids false positives from stale files
     # but also avoids noisy connection attempts).
     module Discover
-      PID_FILE_GLOB = File.join(Dir.tmpdir, "clacky-master-*.pid").freeze
       PID_FILE_REGEX = /clacky-master-(\d+)\.pid\z/.freeze
 
       module_function
@@ -41,7 +40,9 @@ module Clacky
       #
       # @return [Array<Hash>] sorted by port ascending
       def find_all_local
-        Dir.glob(PID_FILE_GLOB).filter_map do |path|
+        directory = PidFiles.directory
+        Dir.glob("clacky-master-*.pid", base: directory).filter_map do |filename|
+          path = File.join(directory, filename)
           m = path.match(PID_FILE_REGEX)
           next nil unless m
 

data/lib/clacky/server/http_server.rb

@@ -110,6 +110,15 @@ module Clacky
 
       def show_tool_call(name, args)
         args_data = args.is_a?(String) ? (JSON.parse(args) rescue args) : args
+        if Clacky::Tools::AskUser.feedback_tool?(name)
+          questions = Clacky::Tools::AskUser.normalize_questions(args_data)
+          first = questions.first || {}
+          @events << { type: "request_feedback", session_id: @session_id,
+                       request_id: Clacky::Tools::AskUser.fetch_key(args_data, :request_id),
+                       context: Clacky::Tools::AskUser.fetch_key(args_data, :context).to_s,
+                       question: first[:question].to_s, options: first[:options] || [], questions: questions }
+          return
+        end
         summary   = tool_call_summary(name, args_data)
         @events << stamp({ type: "tool_call", session_id: @session_id, name: name, args: args_data, summary: summary })
       end
@@ -700,6 +709,7 @@ module Clacky
         when ["POST",   "/api/browser/configure"]  then api_browser_configure(req, res)
         when ["POST",   "/api/browser/reload"]    then api_browser_reload(res)
         when ["POST",   "/api/browser/toggle"]    then api_browser_toggle(res)
+        when ["POST",   "/api/browser/settings"]  then api_browser_settings(req, res)
         when ["GET",    "/api/backup/status"]     then api_backup_status(res)
         when ["POST",   "/api/backup/run"]        then api_backup_run(res)
         when ["GET",    "/api/backup/download"]   then api_backup_download(res)
@@ -732,7 +742,8 @@ module Clacky
         when ["DELETE", "/api/trash"]     then api_trash_delete(req, res)
         when ["GET",    "/api/trash/sessions"]     then api_trash_sessions(req, res)
         when ["POST",   "/api/trash/sessions/restore"] then api_trash_session_restore(req, res)
-        when ["DELETE", "/api/trash/sessions"]     then api_trash_sessions_delete(req, res)
+        when ["POST",   "/api/trash/sessions/delete"]  then api_trash_sessions_delete(req, res)
+        when ["POST",   "/api/archive/sessions/delete"] then api_archive_sessions_delete(req, res)
         when ["GET",    "/api/profile"]   then api_profile_get(res)
         when ["PUT",    "/api/profile"]   then api_profile_put(req, res)
         when ["GET",    "/api/memories"]  then api_memories_list(res)
@@ -869,6 +880,9 @@ module Clacky
           elsif method == "PATCH" && path.match?(%r{^/api/sessions/[^/]+/project$})
             session_id = path.sub("/api/sessions/", "").sub("/project", "")
             api_update_session_project(session_id, req, res)
+          elsif method == "PATCH" && path.match?(%r{^/api/sessions/[^/]+/permission_mode$})
+            session_id = path.split("/")[3]
+            api_switch_session_permission_mode(session_id, req, res)
           elsif method == "PATCH" && path.match?(%r{^/api/sessions/[^/]+/model$})
             session_id = path.sub("/api/sessions/", "").sub("/model", "")
             api_switch_session_model(session_id, req, res)
@@ -949,6 +963,9 @@ module Clacky
           elsif method == "PATCH" && path.match?(%r{^/api/projects/[^/]+$})
             project_id = path.sub("/api/projects/", "")
             api_update_project(project_id, req, res)
+          elsif method == "POST" && path.match?(%r{^/api/projects/[^/]+/sessions/archive$})
+            project_id = path.sub("/api/projects/", "").sub("/sessions/archive", "")
+            api_archive_project_sessions(project_id, res)
           elsif method == "DELETE" && path.match?(%r{^/api/projects/[^/]+/sessions$})
             project_id = path.sub("/api/projects/", "").sub("/sessions", "")
             api_delete_project_sessions(project_id, res)
@@ -967,11 +984,13 @@ module Clacky
         query        = URI.decode_www_form(req.query_string.to_s).to_h
         limit        = [query["limit"].to_i.then { |n| n > 0 ? n : 15 }, 50].min
         before       = query["before"].to_s.strip.then  { |v| v.empty? ? nil : v }
+        before_id    = query["before_id"].to_s.strip.then { |v| v.empty? ? nil : v }
         q            = query["q"].to_s.strip.then       { |v| v.empty? ? nil : v }
         q_scope      = query["q_scope"].to_s.strip.then { |v| %w[name content].include?(v) ? v : "name" }
         date         = query["date"].to_s.strip.then    { |v| v.empty? ? nil : v }
         type         = query["type"].to_s.strip.then    { |v| v.empty? ? nil : v }
         exclude_type = query["exclude_type"].to_s.split(",").map(&:strip).reject(&:empty?).then { |v| v.empty? ? nil : v }
+        archived     = %w[1 true yes].include?(query["archived"].to_s.strip.downcase)
         # 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 }
@@ -981,16 +1000,24 @@ module Clacky
         # in the project section, so they must not eat into this page's quota.
         # Search (no before) keeps the original semantics: without a type filter
         # it may still match project sessions.
-        exclude_project = before ? true : !!type
-        sessions = @registry.list(limit: limit + 1, before: before, q: q, q_scope: q_scope, date: date, type: type, exclude_type: exclude_type, exclude_project: exclude_project)
+        #
+        # The archive view is the exception: it groups archived sessions by
+        # project by hand, so project membership must survive both filters.
+        exclude_project = archived ? false : (before ? true : !!type)
+        sessions = @registry.list(limit: limit + 1, before: before, before_id: before_id, q: q, q_scope: q_scope, date: date, type: type, exclude_type: exclude_type, exclude_project: exclude_project, archived: archived)
 
         pinned_part, non_pinned_part = sessions.partition { |s| s[:pinned] }
         has_more = non_pinned_part.size > limit
         non_pinned_part = non_pinned_part.first(limit)
         sessions = pinned_part + non_pinned_part
 
-        json_response(res, 200, { sessions: sessions, has_more: has_more,
-                                  groups: @registry.group_stats_all })
+        payload = { sessions: sessions, has_more: has_more, next_cursor: non_pinned_part.last&.dig(:cursor),
+                    groups: @registry.group_stats_all }
+        # The archive page offers "delete all", so it needs the size of the whole
+        # archive — the paged `sessions` array only ever shows one page of it.
+        payload[:archived_count] = @registry.archived_count if archived
+
+        json_response(res, 200, payload)
       end
 
       # GET /api/sessions/:id — fetch a single session by id (memory + disk merged).
@@ -1673,6 +1700,22 @@ module Clacky
         json_response(res, 500, { ok: false, error: e.message })
       end
 
+      # POST /api/browser/settings
+      # Body: { screenshot_max_base64_bytes: 300000 }
+      # The field is optional — omitting it keeps the current value.
+      def api_browser_settings(req, res)
+        body = JSON.parse(req.body.to_s) rescue {}
+
+        settings = @browser_manager.update_screenshot_settings(
+          max_base64_bytes: body["screenshot_max_base64_bytes"]
+        )
+        json_response(res, 200, { ok: true }.merge(settings))
+      rescue ArgumentError => e
+        json_response(res, 422, { ok: false, error: e.message })
+      rescue StandardError => e
+        json_response(res, 500, { ok: false, error: e.message })
+      end
+
       # GET /api/backup/status
       def api_backup_status(res)
         json_response(res, 200, BackupManager.status)
@@ -2284,38 +2327,66 @@ module Clacky
       end
 
       # PATCH /api/config/search
-      # Body: { provider: "tavily"|"", key?: "..." }
+      # Body: { provider?: "tavily"|"deepseek_web"|"", key?: "..." }
+      # Omitted fields keep their current value.
       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)
+        if body.key?("provider") && !search_provider_known?(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 })
+        current = Clacky::SearchConfig.load
+        final_provider = body.key?("provider") ? provider : current["provider"]
+        final_key      = body.key?("key") ? key : current["key"]
+
+        # deepseek_web falls back to the configured model key, so it may be
+        # saved without one. Every other searcher is a script that reads the
+        # key from CLACKY_SEARCH_KEY and cannot run without it.
+        if !final_provider.empty? &&
+           final_provider != Clacky::SearchConfig::DEEPSEEK_WEB &&
+           final_key.to_s.strip.empty?
+          return json_response(res, 422, {
+            error: "API key is required for search provider '#{final_provider}'"
+          })
+        end
+
+        Clacky::SearchConfig.save(
+          provider: body.key?("provider") ? provider : nil,
+          key: body.key?("key") ? key : nil
+        )
+        config = Clacky::SearchConfig.load
+        json_response(res, 200, { ok: true, provider: config["provider"] })
       rescue => e
         json_response(res, 422, { error: e.message })
       end
 
+      private def search_provider_known?(provider)
+        return true if provider.empty?
+        return true if provider == Clacky::SearchConfig::DEEPSEEK_WEB
+
+        !Clacky::Utils::SearcherManager.path_for(provider).nil?
+      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.
+      # Runs the configured engine 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?("****")
+        return test_deepseek_web_search(res, key) if provider == Clacky::SearchConfig::DEEPSEEK_WEB
+
+        script = Clacky::Utils::SearcherManager.path_for(provider)
+        return json_response(res, 200, { ok: false, message: "searcher not found: #{provider}" }) unless script
 
         stdout, stderr, status = Clacky::Utils::ParserManager.capture3_with_timeout(
           { "CLACKY_SEARCH_KEY" => key },
@@ -2344,6 +2415,23 @@ module Clacky
         json_response(res, 200, { ok: false, message: e.message })
       end
 
+      private def test_deepseek_web_search(res, key)
+        key = @agent_config.deepseek_web_key.to_s if key.empty?
+        if key.empty?
+          return json_response(res, 200, {
+            ok: false, message: "No DeepSeek key: fill one in or configure a DeepSeek / OpenClacky model"
+          })
+        end
+
+        results = Clacky::DeepSeekWebTools.search(
+          query: "openclacky", count: 1, api_key: key,
+          base_url: @agent_config.deepseek_web_base_url(key)
+        )
+        json_response(res, 200, { ok: true, message: "Returned #{results.size} 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-
@@ -4679,19 +4767,39 @@ module Clacky
           return
         end
 
-        # Support HTTP Range requests for video seeking
+        # Support a single HTTP byte range for media seeking. Browsers normally
+        # send an explicit or open-ended start, while other clients may use the
+        # standard suffix form ("bytes=-N").
         range_header = req["Range"]
         if range_header && range_header =~ /\Abytes=(\d*)-(\d*)\z/
-          start_byte = ($1.empty? ? 0 : $1.to_i)
-          end_byte   = ($2.empty? ? file_size - 1 : $2.to_i)
-          end_byte   = [end_byte, file_size - 1].min
+          first, last = $1, $2
+          unsatisfiable = file_size.zero?
+
+          if first.empty?
+            suffix_length = last.to_i
+            unsatisfiable ||= suffix_length.zero?
+            start_byte = [file_size - suffix_length, 0].max
+            end_byte = file_size - 1
+          else
+            start_byte = first.to_i
+            end_byte = last.empty? ? file_size - 1 : [last.to_i, file_size - 1].min
+            unsatisfiable ||= start_byte >= file_size || end_byte < start_byte
+          end
 
-          res.status = 206
-          res["Content-Type"]  = mime
-          res["Content-Range"] = "bytes #{start_byte}-#{end_byte}/#{file_size}"
+          res["Content-Type"] = mime
           res["Accept-Ranges"] = "bytes"
-          res["Content-Length"] = (end_byte - start_byte + 1).to_s
-          IO.binread(path, end_byte - start_byte + 1, start_byte).then { |data| res.body = data }
+          if unsatisfiable
+            res.status = 416
+            res["Content-Range"] = "bytes */#{file_size}"
+            res["Content-Length"] = "0"
+            res.body = ""
+          else
+            length = end_byte - start_byte + 1
+            res.status = 206
+            res["Content-Range"] = "bytes #{start_byte}-#{end_byte}/#{file_size}"
+            res["Content-Length"] = length.to_s
+            res.body = IO.binread(path, length, start_byte)
+          end
         else
           res.status         = 200
           res["Content-Type"] = mime
@@ -6005,20 +6113,23 @@ module Clacky
         json_response(res, 200, { ok: true, session_id: session_id })
       end
 
-      # DELETE /api/trash/sessions?days_old=N
-      # Bulk: permanently delete sessions older than N days (default: 7).
+      # POST /api/trash/sessions/delete
+      # Body: { session_ids: ["...", ...] }
+      # Bulk: permanently delete exactly these sessions. The caller decides the
+      # scope (the page's filters live in the browser), so an empty list is
+      # rejected rather than read as "everything".
       private def api_trash_sessions_delete(req, res)
-        query    = URI.decode_www_form(req.query_string.to_s).to_h
-        days_old = query["days_old"].to_s.strip
-        days_i   = days_old.empty? ? 7 : days_old.to_i
+        raw = parse_json_body(req)["session_ids"]
+        ids = raw.is_a?(Array) ? raw.map { |id| id.to_s.strip }.reject(&:empty?) : []
 
-        deleted = @session_manager.cleanup_trash(days: days_i)
+        if ids.empty?
+          json_response(res, 400, { ok: false, error: "session_ids is required" })
+          return
+        end
 
-        json_response(res, 200, {
-          ok:            true,
-          deleted_count: deleted,
-          days_old:      days_i
-        })
+        deleted = @session_manager.permanent_delete_trash_sessions(ids)
+
+        json_response(res, 200, { ok: true, deleted_count: deleted })
       end
 
       # ── Trash helpers (private) ─────────────────────────────────────
@@ -6468,9 +6579,17 @@ module Clacky
             provider_id:       m["provider_id"],
             provider_name:     provider && provider["name"],
             provider_name_key: provider && provider["name_key"],
+            # Where the row's provider manages keys / billing — the picker
+            # links to it from the per-row top-up shortcut.
+            website_url:       provider && provider["website_url"],
             capabilities:      m["capabilities"],
             remark:            m["remark"],
-            type:              m["type"]
+            type:              m["type"],
+            # Sub-model list for this row: the models of the provider its
+            # endpoint belongs to (same rule the session status bar uses), so
+            # the picker can offer the switcher on every row and not only on
+            # the session's current one.
+            sub_models:        provider_id ? Clacky::Providers.models(provider_id) : []
           }
         end
         # Sidecar capability configs (media/ocr) and auto-injected entries are
@@ -7213,6 +7332,45 @@ module Clacky
         json_response(res, 500, { error: e.message })
       end
 
+      # POST /api/projects/:id/sessions/archive - archive every live session in a project
+      def api_archive_project_sessions(project_id, res)
+        return json_response(res, 404, { error: "Project not found" }) unless @project_manager.find(project_id)
+
+        archived = _archive_project_sessions(project_id)
+        json_response(res, 200, { ok: true, archived: archived })
+      rescue => e
+        json_response(res, 500, { error: e.message })
+      end
+
+      # Sessions already in the archive keep their original archived_at, so the
+      # archive page stays ordered by when the user actually put them away.
+      private def _archive_project_sessions(project_id)
+        archived = 0
+        now      = Time.now.iso8601
+
+        @session_manager.all_sessions.each do |session_data|
+          next unless session_data[:project_id].to_s == project_id
+          next if session_data[:archived_at]
+
+          sid  = session_data[:session_id]
+          live = nil
+          @registry.with_session(sid) { |s| live = s[:agent] }
+
+          if live
+            live.archived_at = now
+            @session_manager.save(live.to_session_data(updated_at: Time.now))
+          else
+            # Untouched on disk: patch the loaded row rather than restoring an
+            # agent for every session in the project just to stamp one field.
+            @session_manager.save(session_data.merge(archived_at: now, updated_at: now))
+          end
+
+          broadcast(sid, { type: "session_updated", session_id: sid, archived_at: now })
+          archived += 1
+        end
+        archived
+      end
+
       private def _delete_project_sessions(project_id)
         deleted = 0
         @session_manager.all_sessions.each do |session_data|
@@ -7264,6 +7422,11 @@ module Clacky
         body = parse_json_body(req)
         new_name = body["name"]&.to_s&.strip
         pinned = body["pinned"]
+        archived = body["archived"]
+
+        if !archived.nil? && archived != true && archived != false
+          return json_response(res, 400, { error: "archived must be true or false" })
+        end
 
         return json_response(res, 404, { error: "Session not found" }) unless @registry.ensure(session_id)
 
@@ -7279,6 +7442,11 @@ module Clacky
         if !pinned.nil?
           agent.pinned = pinned
         end
+
+        # Update archived status if provided
+        if !archived.nil?
+          agent.archived_at = archived ? Time.now.iso8601 : nil
+        end
         
         # Save session data
         @session_manager.save(agent.to_session_data(updated_at: Time.now))
@@ -7287,16 +7455,36 @@ module Clacky
         update_data = { type: "session_updated", session_id: session_id }
         update_data[:name] = new_name if new_name && !new_name.empty?
         update_data[:pinned] = pinned unless pinned.nil?
+        update_data[:archived_at] = agent.archived_at unless archived.nil?
         broadcast(session_id, update_data)
         
         response_data = { ok: true }
         response_data[:name] = new_name if new_name && !new_name.empty?
         response_data[:pinned] = pinned unless pinned.nil?
+        response_data[:archived_at] = agent.archived_at unless archived.nil?
         json_response(res, 200, response_data)
       rescue => e
         json_response(res, 500, { error: e.message })
       end
 
+      # PATCH /api/sessions/:id/permission_mode — session-only, never global.
+      def api_switch_session_permission_mode(session_id, req, res)
+        mode = parse_json_body(req)["permission_mode"].to_s
+        unless %w[confirm_all auto_approve].include?(mode)
+          return json_response(res, 400, { error: "Invalid permission mode" })
+        end
+        return json_response(res, 404, { error: "Session not found" }) unless @registry.ensure(session_id)
+
+        @registry.with_session(session_id) do |session|
+          agent = session[:agent]
+          return json_response(res, 404, { error: "Session not found" }) unless agent
+          agent.permission_mode = mode
+          @session_manager.save(agent.to_session_data(updated_at: Time.now))
+        end
+        broadcast_session_update(session_id)
+        json_response(res, 200, { ok: true, permission_mode: mode })
+      end
+
       def api_switch_session_model(session_id, req, res)
         body = parse_json_body(req)
         model_id = body["model_id"].to_s.strip
@@ -7540,6 +7728,29 @@ module Clacky
         json_response(res, 201, { session: @registry.snapshot(fork_id) })
       end
 
+      # POST /api/archive/sessions/delete — soft-deletes into the recycle bin.
+      # With `session_ids`, only those still-archived chats go; without a body,
+      # the whole archive (the page is paged, so only the server can list it).
+      # An explicit empty list is rejected so "matches nothing" never means "all".
+      def api_archive_sessions_delete(req, res)
+        body = parse_json_body(req)
+        ids  = @registry.list(archived: true).map { |s| s[:id] }
+
+        if !body.is_a?(Hash) || body.key?("session_ids")
+          raw       = body.is_a?(Hash) ? body["session_ids"] : nil
+          requested = raw.is_a?(Array) ? raw.map { |id| id.to_s.strip }.reject(&:empty?) : []
+          return json_response(res, 400, { ok: false, error: "session_ids must not be empty" }) if requested.empty?
+
+          ids &= requested
+        end
+
+        # `list` just read these ids off disk, so skip the per-id existence
+        # probe — `load` re-parses every session file for each call.
+        ids.each { |session_id| soft_delete_session!(session_id, on_disk: true) }
+
+        json_response(res, 200, { ok: true, deleted_count: ids.size })
+      end
+
       def api_delete_session(session_id, res)
         # A session exists if it's either in the runtime registry OR on disk.
         # Old sessions that were never restored into memory this server run
@@ -7547,28 +7758,36 @@ module Clacky
         # must still be able to delete them. Previously this endpoint only
         # consulted @registry and returned 404 for disk-only sessions,
         # causing the "can't delete old sessions" bug.
-        in_registry = @registry.exist?(session_id)
-        on_disk     = !@session_manager.load(session_id).nil?
+        return json_response(res, 404, { error: "Session not found" }) unless soft_delete_session!(session_id)
 
-        unless in_registry || on_disk
-          return json_response(res, 404, { error: "Session not found" })
-        end
+        json_response(res, 200, { ok: true })
+      end
+
+      # Move one session to the recycle bin and tell everyone who can see it.
+      # Returns false when the session is unknown — neither live nor on disk.
+      #
+      # `on_disk` skips the existence probe for callers that already scanned the
+      # disk themselves: `SessionManager#load` re-parses every session file until
+      # it finds a match, which is far too expensive to run per id in a bulk path.
+      private def soft_delete_session!(session_id, on_disk: nil)
+        in_registry = @registry.exist?(session_id)
+        on_disk     = !@session_manager.load(session_id).nil? if on_disk.nil?
+        return false unless in_registry || on_disk
 
-        # Registry delete is best-effort — only meaningful when the session
-        # is actually live (cancels idle timer, interrupts the agent thread).
-        # For disk-only sessions this is a no-op and returns false, which is
-        # fine and no longer blocks the disk cleanup below.
+        # Registry delete is best-effort — only meaningful when the session is
+        # actually live (cancels idle timer, interrupts the agent thread). For
+        # disk-only sessions this is a no-op and returns false, which is fine and
+        # no longer blocks the disk cleanup below.
         @registry.delete(session_id) if in_registry
 
         # Soft-delete: move session to trash instead of permanently destroying it.
         @session_manager.soft_delete(session_id) if on_disk
 
-        # Notify any still-connected clients (mainly matters when the
-        # session was live, but harmless otherwise).
+        # Notify any still-connected clients (mainly matters when the session was
+        # live, but harmless otherwise) so other tabs drop the row too.
         broadcast(session_id, { type: "session_deleted", session_id: session_id })
         unsubscribe_all(session_id)
-
-        json_response(res, 200, { ok: true })
+        true
       end
 
       # Export a session bundle as a .zip download containing:
@@ -7769,6 +7988,15 @@ module Clacky
           end
           handle_user_message(session_id, msg["content"].to_s, (msg["files"] || []) + raw_images, references: msg["references"] || [])
 
+        when "feedback_intervene"
+          session_id = msg["session_id"] || conn.session_id
+          session = @registry.get(session_id)
+          if session&.dig(:ui)&.intervene_feedback(msg["request_id"])
+            # Finish the handoff before processing the next message on this connection.
+            # An immediate submission then uses the ordinary awaiting-feedback path.
+            session[:thread]&.join
+          end
+
         when "confirmation"
           session_id = msg["session_id"] || conn.session_id
           deliver_confirmation(session_id, msg["id"], msg["result"])
@@ -7787,7 +8015,9 @@ module Clacky
           pinned_part, non_pinned_part = page.partition { |s| s[:pinned] }
           non_pinned_limit = [10 - pinned_part.size, 0].max
           has_more = non_pinned_part.size > non_pinned_limit
-          all_sessions = pinned_part + non_pinned_part.first(non_pinned_limit)
+          non_pinned_part = non_pinned_part.first(non_pinned_limit)
+          next_cursor = non_pinned_part.last&.dig(:cursor)
+          all_sessions = pinned_part + non_pinned_part
           projects = @project_manager.all
           if projects.any?
             project_ids = projects.map { |p| p[:id] }
@@ -7799,7 +8029,7 @@ module Clacky
             paged_ids = all_sessions.map { |s| s[:id] }.to_set
             all_sessions += project_sessions.reject { |s| paged_ids.include?(s[:id]) }
           end
-          conn.send_json(type: "session_list", sessions: all_sessions, has_more: has_more,
+          conn.send_json(type: "session_list", sessions: all_sessions, has_more: has_more, next_cursor: next_cursor,
                          groups: groups, projects: projects)
 
         when "run_task"
@@ -7871,7 +8101,6 @@ module Clacky
         return unless @registry.exist?(session_id)
 
         session = @registry.get(session_id)
-        
         mode = @agent_config.input_behavior
         queued = false
         queued_created_at = nil
@@ -7916,8 +8145,8 @@ module Clacky
         # Auto-name the session from the first user message (before agent starts running).
         # Skip if the name looks like it was set by the user (not a system-generated "Session N").
         if agent.history.empty? && agent.name.match?(/\ASession \d+\z/)
-          auto_name = content.gsub(/\s+/, " ").strip[0, 30]
-          auto_name += "…" if content.strip.length > 30
+          auto_name = content.gsub(/\s+/, " ").strip[0, 80]
+          auto_name += "…" if content.strip.length > 80
           agent.rename(auto_name)
           broadcast(session_id, { type: "session_renamed", session_id: session_id, name: auto_name })
         end
@@ -8227,11 +8456,14 @@ module Clacky
           if e.is_a?(Clacky::InsufficientCreditError) && e.provider_id
             preset = Clacky::Providers::PRESETS[e.provider_id]
             top_up_url = preset && preset["website_url"]
+          elsif e.respond_to?(:action_url) && e.action_url
+            top_up_url = e.action_url
           end
           user_message = e.respond_to?(:display_message) && e.display_message ? e.display_message : e.message
           raw_message  = e.respond_to?(:raw_message) ? e.raw_message : nil
           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)
+          agent.record_error_event(user_message, code: code, top_up_url: top_up_url, raw_message: raw_message)
           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, updated_at: Time.now))
         end

data/lib/clacky/server/model_prices.rb

@@ -6,7 +6,10 @@ module Clacky
     # Resolves each model's input/output price (USD per 1M tokens) from
     # Clacky::ModelPricing plus a cost ratio vs the baseline model, so the
     # web UI never hardcodes prices - updating PRICING_TABLE is enough.
-    # Prices are post-promotion; `discount` is present when a rule applied.
+    # Prices are what the platform actually bills: post-promotion rates plus
+    # any lane markup. `discount` is present when a promotion applied,
+    # carrying both the rate and its reason ("channel" or "promo") so the UI
+    # can pick the right explanation.
     module ModelPrices
       BASELINE_MODEL = "claude-sonnet-5"
 
@@ -21,15 +24,17 @@ module Clacky
           pricing = Clacky::ModelPricing.get_pricing(name)
           pricing = Clacky::ModelPricing.resolve_deepseek_tier(pricing, now) if pricing && pricing[:deepseek]
           next unless pricing
-          rate = Clacky::ModelPricing.discount_rate(name)
+          info = Clacky::ModelPricing.discount_info(name)
+          rate = info ? info[:rate] : 1.0
+          markup = Clacky::ModelPricing.markup_rate(name)
           # Rates are not powers of two, so the discounted product carries float
           # noise (3.0 * 0.95 == 2.8499999999999996) that would surface verbatim
           # in the picker tooltips. Four decimals is already finer than any
           # listed price.
-          pin  = (pricing[:input][:default] * rate).round(4)
-          pout = (pricing[:output][:default] * rate).round(4)
+          pin  = (pricing[:input][:default] * rate * markup).round(4)
+          pout = (pricing[:output][:default] * rate * markup).round(4)
           entry = { in: pin, out: pout, ratio: (pin + pout) / base_total }
-          entry[:discount] = { rate: rate } if rate < 1.0
+          entry[:discount] = { rate: rate, reason: info[:reason] } if rate < 1.0
           prices[name] = entry
         end