openclacky 1.1.6 → 1.2.0

data/lib/clacky/server/http_server.rb

@@ -89,6 +89,11 @@ module Clacky
         @events << { type: "token_usage", session_id: @session_id }.merge(token_data)
       end
 
+      def show_feedback_request(question, context, options)
+        @events << { type: "request_feedback", session_id: @session_id,
+                     question: question, context: context, options: options }
+      end
+
       # Ignore all other UI methods (progress, errors, etc.) during history replay
       def method_missing(name, *args, **kwargs); end
       def respond_to_missing?(name, include_private = false); true; end
@@ -154,8 +159,8 @@ module Clacky
         @agent_config   = agent_config
         @client_factory = client_factory  # callable: -> { Clacky::Client.new(...) }
         @brand_test     = brand_test      # when true, skip remote API calls for license activation
-        @inherited_socket = socket        # TCPServer socket passed from Master (nil = standalone mode)
-        @master_pid       = master_pid    # Master PID so we can send USR1 on upgrade/restart
+        @inherited_socket  = socket        # TCPServer socket passed from Master (nil = standalone mode)
+        @master_pid        = master_pid    # Master PID so we can send USR1 on upgrade/restart
         # Capture the absolute path of the entry script and original ARGV at startup,
         # so api_restart can re-exec the correct binary even if cwd changes later.
         @restart_script = File.expand_path($0)
@@ -186,6 +191,9 @@ module Clacky
         )
         @browser_manager = Clacky::BrowserManager.instance
         @skill_loader    = Clacky::SkillLoader.new(working_dir: nil, brand_config: Clacky::BrandConfig.load)
+        # 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
         # 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.
@@ -201,6 +209,9 @@ module Clacky
       end
 
       def start
+        # One-time migration: move legacy trash contents into file-trash/ subdirectory.
+        Clacky::TrashDirectory.migrate_legacy_if_needed
+
         # Enable console logging for the server process so log lines are visible in the terminal.
         Clacky::Logger.console = true
 
@@ -240,13 +251,13 @@ module Clacky
         shutdown_proc = proc do
           next if shutdown_once
           shutdown_once = true
-          Thread.new do
-            sleep 2
-            Clacky::Logger.warn("[HttpServer] Forced exit after graceful shutdown timeout.")
-            exit!(0)
-          end
-          # Detach the inherited (shared) listen socket BEFORE shutdown so that
-          # WEBrick's cleanup_listener does not call shutdown(SHUT_RDWR)+close on
+          # Persist in-flight agent sessions BEFORE starting the forced-exit
+          # timer, so any new messages added to @history since the last save
+          # are on disk before the new worker reads them after a hot restart.
+          interrupt_all_agents
+
+          # Detach the inherited (shared) listen socket BEFORE WEBrick.shutdown
+          # so that cleanup_listener does not call shutdown(SHUT_RDWR)+close on
           # it — that would propagate to every process sharing the underlying
           # kernel socket (Master + new worker), breaking subsequent accept()
           # on Linux. macOS's BSD stack tolerates this; Linux does not.
@@ -256,8 +267,10 @@ module Clacky
           end
           t1 = Thread.new { @channel_manager.stop rescue nil }
           t2 = Thread.new { Clacky::BrowserManager.instance.stop rescue nil }
+          t3 = Thread.new { @mcp_registry&.shutdown rescue nil }
           t1.join(1.5)
           t2.join(1.5)
+          t3.join(1.5)
           server.shutdown rescue nil
         end
         trap("INT")  { shutdown_proc.call }
@@ -380,6 +393,8 @@ module Clacky
         when ["POST",   "/api/cron-tasks"]    then api_create_cron_task(req, res)
         when ["GET",    "/api/skills"]         then api_list_skills(res)
         when ["GET",    "/api/config"]        then api_get_config(res)
+        when ["GET",    "/api/config/settings"]  then api_get_settings(res)
+        when ["PATCH",  "/api/config/settings"]  then api_update_settings(req, res)
         when ["POST",   "/api/config/models"] then api_add_model(req, res)
         when ["POST",   "/api/config/test"]   then api_test_config(req, res)
         when ["GET",    "/api/providers"]     then api_list_providers(res)
@@ -400,11 +415,15 @@ module Clacky
         when ["GET",    "/api/trash"]     then api_trash(req, res)
         when ["POST",   "/api/trash/restore"] then api_trash_restore(req, res)
         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 ["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)
         when ["POST",   "/api/memories"]  then api_memories_create(req, res)
         when ["GET",    "/api/channels"]          then api_list_channels(res)
+        when ["GET",    "/api/mcp"]               then api_mcp_list(res)
         when ["POST",   "/api/tool/browser"]      then api_tool_browser(req, res)
         when ["POST",   "/api/upload"]            then api_upload_file(req, res)
         when ["POST",   "/api/file-action"]       then api_file_action(req, res)
@@ -412,6 +431,9 @@ module Clacky
         when ["GET",    "/api/version"]           then api_get_version(res)
         when ["POST",   "/api/version/upgrade"]   then api_upgrade_version(req, res)
         when ["POST",   "/api/restart"]           then api_restart(req, res)
+        when ["GET",    "/api/billing/summary"]   then api_billing_summary(req, res)
+        when ["GET",    "/api/billing/daily"]     then api_billing_daily(req, res)
+        when ["GET",    "/api/billing/records"]   then api_billing_records(req, res)
         when ["PATCH",  "/api/sessions/:id/model"] then api_switch_session_model(req, res)
         when ["PATCH",  "/api/sessions/:id/working_dir"] then api_change_session_working_dir(req, res)
         else
@@ -433,6 +455,26 @@ module Clacky
           elsif method == "DELETE" && path.start_with?("/api/channels/")
             platform = path.sub("/api/channels/", "")
             api_delete_channel(platform, res)
+          elsif method == "POST" && path.match?(%r{^/api/mcp/[^/]+/probe$})
+            name = path.sub("/api/mcp/", "").sub("/probe", "")
+            api_mcp_probe(name, res)
+          elsif method == "GET" && path.match?(%r{^/api/mcp/[^/]+/tools$})
+            name = path.sub("/api/mcp/", "").sub("/tools", "")
+            api_mcp_tools(name, res)
+          elsif method == "POST" && path.match?(%r{^/api/mcp/[^/]+/call$})
+            name = path.sub("/api/mcp/", "").sub("/call", "")
+            api_mcp_call(name, req, res)
+          elsif method == "POST" && path == "/api/mcp"
+            api_mcp_create(req, res)
+          elsif method == "PATCH" && path.match?(%r{^/api/mcp/[^/]+/enabled$})
+            name = path.sub("/api/mcp/", "").sub("/enabled", "")
+            api_mcp_toggle(name, req, res)
+          elsif method == "PUT" && path.match?(%r{^/api/mcp/[^/]+$})
+            name = path.sub("/api/mcp/", "")
+            api_mcp_update(name, req, res)
+          elsif method == "DELETE" && path.match?(%r{^/api/mcp/[^/]+$})
+            name = path.sub("/api/mcp/", "")
+            api_mcp_delete(name, req, res)
           elsif method == "GET" && path.match?(%r{^/api/sessions/[^/]+/skills$})
             session_id = path.sub("/api/sessions/", "").sub("/skills", "")
             api_session_skills(session_id, res)
@@ -460,6 +502,9 @@ module Clacky
           elsif method == "DELETE" && path.start_with?("/api/sessions/")
             session_id = path.sub("/api/sessions/", "")
             api_delete_session(session_id, res)
+          elsif method == "DELETE" && path.match?(%r{^/api/trash/sessions/[^/]+$})
+            session_id = path.sub("/api/trash/sessions/", "")
+            api_trash_session_delete_one(session_id, res)
           elsif method == "POST" && path.match?(%r{^/api/config/models/[^/]+/default$})
             id = path.sub("/api/config/models/", "").sub("/default", "")
             api_set_default_model(id, res)
@@ -1062,6 +1107,58 @@ module Clacky
 
       # ── Version API ───────────────────────────────────────────────────────────
 
+      # ── Billing API ────────────────────────────────────────────────────────────
+
+      # GET /api/billing/summary
+      # Returns billing summary for a time period
+      # Query params: period (day|week|month|year|all, default: month)
+      def api_billing_summary(req, res)
+        require_relative "../billing/billing_store"
+
+        query  = URI.decode_www_form(req.query_string.to_s).to_h
+        period = (query["period"] || "month").to_sym
+
+        store   = Clacky::Billing::BillingStore.new
+        summary = store.summary(period: period)
+
+        json_response(res, 200, summary)
+      end
+
+      # GET /api/billing/daily
+      # Returns daily cost breakdown
+      # Query params: days (default: 30)
+      def api_billing_daily(req, res)
+        require_relative "../billing/billing_store"
+
+        query = URI.decode_www_form(req.query_string.to_s).to_h
+        days  = [(query["days"] || "30").to_i, 90].min
+
+        store = Clacky::Billing::BillingStore.new
+        daily = store.daily_breakdown(days: days)
+
+        json_response(res, 200, { days: daily })
+      end
+
+      # GET /api/billing/records
+      # Returns recent billing records
+      # Query params: limit (default: 100), model, session_id
+      def api_billing_records(req, res)
+        require_relative "../billing/billing_store"
+
+        query      = URI.decode_www_form(req.query_string.to_s).to_h
+        limit      = [(query["limit"] || "100").to_i, 500].min
+        model      = query["model"]
+        session_id = query["session_id"]
+
+        store   = Clacky::Billing::BillingStore.new
+        records = store.query(model: model, session_id: session_id, limit: limit)
+
+        json_response(res, 200, {
+          records: records.map(&:to_h),
+          count: records.size
+        })
+      end
+
       # GET /api/version
       # Returns current version and latest version from RubyGems (cached for 1 hour).
       def api_get_version(res)
@@ -1508,6 +1605,270 @@ module Clacky
         json_response(res, 200, { channels: platforms })
       end
 
+      # GET /api/mcp
+      # Lists configured MCP servers without spawning any subprocess. Honors
+      # both ~/.clacky/mcp.json (global) and project-level overrides.
+      def api_mcp_list(res)
+        data = mcp_load_raw_config
+        servers = (data["mcpServers"] || {}).map do |name, spec|
+          next nil unless spec.is_a?(Hash)
+
+          type = (spec["type"] || (spec["url"] ? "http" : "stdio")).to_s
+          {
+            name:        name.to_s,
+            type:        type,
+            description: spec["description"] || "",
+            command:     spec["command"],
+            args:        Array(spec["args"]),
+            url:         spec["url"],
+            disabled:    spec["disabled"] == true,
+            has_env:     spec["env"].is_a?(Hash) && !spec["env"].empty?,
+            has_headers: spec["headers"].is_a?(Hash) && !spec["headers"].empty?,
+          }
+        end.compact
+
+        json_response(res, 200, {
+          configured:    !servers.empty?,
+          config_path:   mcp_config_path,
+          config_exists: File.exist?(mcp_config_path),
+          servers:       servers,
+        })
+      end
+
+      # POST /api/mcp/:name/probe
+      # Spawns the MCP server briefly to fetch its tool catalog, then shuts it
+      # down. Used by the WebUI to display each server's tool list on demand.
+      # No state survives the request — the next agent run does its own lazy spawn.
+      def api_mcp_probe(name, res)
+        registry = Clacky::Mcp::Registry.new(idle_timeout: 0)
+        unless registry.configured?(name)
+          json_response(res, 404, { ok: false, error: "MCP server '#{name}' not found in mcp.json" })
+          return
+        end
+
+        tools = registry.tool_definitions(name).map do |defn|
+          fn = defn[:function] || defn["function"] || {}
+          {
+            name:         fn[:name] || fn["name"],
+            description:  fn[:description] || fn["description"] || "",
+            input_schema: fn[:parameters] || fn["parameters"] || {},
+          }
+        end
+
+        json_response(res, 200, { ok: true, name: name, tools: tools, tool_count: tools.length })
+      rescue Clacky::Mcp::Client::McpError, Clacky::Mcp::Client::TransportError => e
+        json_response(res, 502, { ok: false, error: e.message })
+      rescue StandardError => e
+        json_response(res, 500, { ok: false, error: e.message })
+      ensure
+        registry&.shutdown
+      end
+
+      # GET /api/mcp/:name/tools
+      # Returns the live tool catalog for an MCP server, using the process-wide
+      # registry. The first call cold-starts the server; later calls hit cache.
+      # Subagents use this as a discovery endpoint, replacing the deleted
+      # mcp_call tool's hidden tool list.
+      def api_mcp_tools(name, res)
+        unless mcp_registry.configured?(name)
+          json_response(res, 404, { ok: false, error: "MCP server '#{name}' not found in mcp.json" })
+          return
+        end
+
+        tools = mcp_registry.tool_definitions(name).map do |defn|
+          fn = defn[:function] || defn["function"] || {}
+          {
+            name:         fn[:name] || fn["name"],
+            description:  fn[:description] || fn["description"] || "",
+            input_schema: fn[:parameters] || fn["parameters"] || {},
+          }
+        end
+
+        json_response(res, 200, { ok: true, name: name, tools: tools, tool_count: tools.length })
+      rescue Clacky::Mcp::Client::McpError, Clacky::Mcp::Client::TransportError => e
+        json_response(res, 502, { ok: false, error: e.message })
+      rescue StandardError => e
+        json_response(res, 500, { ok: false, error: e.message })
+      end
+
+      # POST /api/mcp/:name/call  body: { tool: "...", arguments: {...} }
+      # Forwards a tools/call to the configured MCP server and returns its raw
+      # result. Subagents call this from their shell tool via curl — there is
+      # no Ruby-side bridge tool anymore.
+      def api_mcp_call(name, req, res)
+        unless mcp_registry.configured?(name)
+          json_response(res, 404, { ok: false, error: "MCP server '#{name}' not found in mcp.json" })
+          return
+        end
+
+        body = parse_json_body(req) || {}
+        tool = body["tool"] || body[:tool]
+        arguments = body["arguments"] || body[:arguments] || {}
+
+        if tool.nil? || tool.to_s.strip.empty?
+          json_response(res, 400, { ok: false, error: "missing required field: tool" })
+          return
+        end
+
+        result = mcp_registry.call_tool(name, tool, arguments)
+        json_response(res, 200, { ok: true, result: result })
+      rescue Clacky::Mcp::Client::McpError, Clacky::Mcp::Client::TransportError => e
+        json_response(res, 502, { ok: false, error: e.message })
+      rescue StandardError => e
+        json_response(res, 500, { ok: false, error: e.message })
+      end
+
+      private def mcp_config_path
+        File.join(Dir.home, ".clacky", "mcp.json")
+      end
+
+      private def mcp_registry
+        @mcp_registry_mutex.synchronize do
+          @mcp_registry ||= Clacky::Mcp::Registry.new(working_dir: nil)
+        end
+      end
+
+      private def mcp_localhost_only(req, res)
+        ip = req.peeraddr.last rescue nil
+        return true if %w[127.0.0.1 ::1].include?(ip)
+
+        json_response(res, 403, { ok: false, error: "MCP write operations are only allowed from localhost" })
+        false
+      end
+
+      private def mcp_load_raw_config
+        return { "mcpServers" => {} } unless File.exist?(mcp_config_path)
+
+        data = JSON.parse(File.read(mcp_config_path))
+        data["mcpServers"] ||= data.delete("servers") || {}
+        data
+      rescue JSON::ParserError
+        { "mcpServers" => {} }
+      end
+
+      private def mcp_write_raw_config(data)
+        FileUtils.mkdir_p(File.dirname(mcp_config_path))
+        File.write(mcp_config_path, JSON.pretty_generate(data) + "\n")
+      end
+
+      private def mcp_validate_spec(body)
+        name = body["name"].to_s.strip
+        return [nil, nil, "name is required"]    if name.empty?
+        return [nil, nil, "name contains invalid characters"] unless name.match?(/\A[A-Za-z0-9_\-]+\z/)
+
+        type = (body["type"] || (body["url"] ? "http" : "stdio")).to_s
+        case type
+        when "stdio"
+          command = body["command"].to_s.strip
+          return [nil, nil, "command is required"] if command.empty?
+          spec = { "command" => command }
+          spec["args"] = Array(body["args"]).map(&:to_s) if body["args"]
+          spec["env"]  = body["env"].transform_values(&:to_s) if body["env"].is_a?(Hash)
+          spec["cwd"]  = body["cwd"].to_s if body["cwd"].is_a?(String) && !body["cwd"].empty?
+        when "http", "streamable-http"
+          url = body["url"].to_s.strip
+          return [nil, nil, "url is required for http type"] if url.empty?
+          return [nil, nil, "url must be http(s)"] unless url.match?(%r{\Ahttps?://}i)
+          spec = { "type" => "http", "url" => url }
+          spec["headers"] = body["headers"].transform_values(&:to_s) if body["headers"].is_a?(Hash)
+        else
+          return [nil, nil, "unsupported type '#{type}' (use stdio or http)"]
+        end
+
+        spec["description"] = body["description"].to_s if body["description"].is_a?(String) && !body["description"].empty?
+        [name, spec, nil]
+      end
+
+      # POST /api/mcp  { name, command, args[], env{}, cwd?, description? }
+      def api_mcp_create(req, res)
+        return unless mcp_localhost_only(req, res)
+
+        body = parse_json_body(req)
+        name, spec, err = mcp_validate_spec(body)
+        if err
+          json_response(res, 400, { ok: false, error: err })
+          return
+        end
+
+        data = mcp_load_raw_config
+        if data["mcpServers"].key?(name)
+          json_response(res, 409, { ok: false, error: "MCP server '#{name}' already exists. Use PUT to update." })
+          return
+        end
+
+        data["mcpServers"][name] = spec
+        mcp_write_raw_config(data)
+        json_response(res, 200, { ok: true, name: name, config_path: mcp_config_path })
+      end
+
+      # PUT /api/mcp/:name  { command, args[], env{}, cwd?, description? }
+      # Replaces the entire spec. Path :name wins over body name.
+      def api_mcp_update(name, req, res)
+        return unless mcp_localhost_only(req, res)
+
+        body = parse_json_body(req).merge("name" => name)
+        _, spec, err = mcp_validate_spec(body)
+        if err
+          json_response(res, 400, { ok: false, error: err })
+          return
+        end
+
+        data = mcp_load_raw_config
+        unless data["mcpServers"].key?(name)
+          json_response(res, 404, { ok: false, error: "MCP server '#{name}' not found" })
+          return
+        end
+
+        data["mcpServers"][name] = spec
+        mcp_write_raw_config(data)
+        json_response(res, 200, { ok: true, name: name })
+      end
+
+      # DELETE /api/mcp/:name
+      def api_mcp_delete(name, req, res)
+        return unless mcp_localhost_only(req, res)
+
+        data = mcp_load_raw_config
+        unless data["mcpServers"].key?(name)
+          json_response(res, 404, { ok: false, error: "MCP server '#{name}' not found" })
+          return
+        end
+
+        data["mcpServers"].delete(name)
+        mcp_write_raw_config(data)
+        json_response(res, 200, { ok: true, name: name })
+      end
+
+      # PATCH /api/mcp/:name/enabled  body: { enabled: true|false }
+      def api_mcp_toggle(name, req, res)
+        return unless mcp_localhost_only(req, res)
+
+        body = parse_json_body(req) || {}
+        enabled = body["enabled"]
+        if enabled.nil? || ![true, false].include?(enabled)
+          json_response(res, 400, { ok: false, error: "enabled (boolean) is required" })
+          return
+        end
+
+        data = mcp_load_raw_config
+        spec = data["mcpServers"][name]
+        unless spec.is_a?(Hash)
+          json_response(res, 404, { ok: false, error: "MCP server '#{name}' not found" })
+          return
+        end
+
+        if enabled
+          spec.delete("disabled")
+        else
+          spec["disabled"] = true
+        end
+        mcp_write_raw_config(data)
+
+        @mcp_registry_mutex.synchronize { @mcp_registry&.reload }
+
+        json_response(res, 200, { ok: true, name: name, disabled: spec["disabled"] == true })
+      end
+
       # POST /api/channels/:platform/send
       # Proactively send a message to a user via the given IM platform.
       #
@@ -2306,6 +2667,94 @@ module Clacky
         })
       end
 
+      # ── Session trash endpoints ──────────────────────────────────────
+
+      # GET /api/trash/sessions
+      # Lists all soft-deleted sessions in the session trash directory.
+      private def api_trash_sessions(_req, res)
+        sessions = @session_manager.list_trash_sessions
+
+        result = sessions.map do |s|
+          {
+            session_id:  s[:session_id],
+            name:        s[:name] || s[:title] || s[:session_id],
+            created_at:  s[:created_at],
+            updated_at:  s[:updated_at],
+            deleted_at:  s[:deleted_at],
+            total_tasks: s.dig(:stats, :total_tasks) || 0,
+            file_size:   s[:file_size] || 0,
+            model:       s[:model],
+            working_dir: s[:working_dir]
+          }
+        end
+
+        total_size = result.sum { |s| s[:file_size] }
+
+        json_response(res, 200, {
+          ok:         true,
+          sessions:   result,
+          count:      result.size,
+          total_size: total_size
+        })
+      end
+
+      # POST /api/trash/sessions/restore
+      # Body: { session_id: "..." }
+      # Restores a soft-deleted session back to the active sessions list.
+      private def api_trash_session_restore(req, res)
+        data       = parse_json_body(req)
+        session_id = data["session_id"].to_s.strip
+
+        if session_id.empty?
+          json_response(res, 400, { ok: false, error: "session_id is required" })
+          return
+        end
+
+        unless @session_manager.restore_session(session_id)
+          json_response(res, 404, { ok: false, error: "Session not found in trash: #{session_id}" })
+          return
+        end
+
+        # Load the restored session into the registry so it behaves like any
+        # other live session (status, agent, snapshot all available).
+        @registry.ensure(session_id)
+        session = @registry.session_summary(session_id)
+
+        # Use broadcast_all because no client is subscribed to a session that
+        # was just sitting in the trash — broadcast(session_id, …) would reach
+        # zero recipients.
+        broadcast_all(type: "session_restored", session: session)
+
+        json_response(res, 200, { ok: true, session: session })
+      end
+
+      # DELETE /api/trash/sessions/:id
+      # Permanently delete a single session from the trash.
+      private def api_trash_session_delete_one(session_id, res)
+        unless @session_manager.permanent_delete_trash_session(session_id)
+          json_response(res, 404, { ok: false, error: "Session not found in trash: #{session_id}" })
+          return
+        end
+
+        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).
+      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
+
+        deleted = @session_manager.cleanup_trash(days: days_i)
+
+        json_response(res, 200, {
+          ok:            true,
+          deleted_count: deleted,
+          days_old:      days_i
+        })
+      end
+
       # ── Trash helpers (private) ─────────────────────────────────────
       # Reads all metadata sidecars in `trash_dir` and returns enriched
       # file records. Silently skips sidecars whose payload file has
@@ -2746,6 +3195,37 @@ module Clacky
         })
       end
 
+      # GET /api/config/settings — return advanced settings
+      def api_get_settings(res)
+        json_response(res, 200, {
+          ok: true,
+          enable_compression: @agent_config.enable_compression,
+          enable_prompt_caching: @agent_config.enable_prompt_caching,
+          memory_update_enabled: @agent_config.memory_update_enabled
+        })
+      end
+
+      # PATCH /api/config/settings — update advanced settings
+      def api_update_settings(req, res)
+        body = parse_json_body(req)
+        return json_response(res, 400, { error: "Invalid JSON" }) unless body
+
+        if body.key?("enable_compression")
+          @agent_config.enable_compression = !!body["enable_compression"]
+        end
+        if body.key?("enable_prompt_caching")
+          @agent_config.enable_prompt_caching = !!body["enable_prompt_caching"]
+        end
+        if body.key?("memory_update_enabled")
+          @agent_config.memory_update_enabled = !!body["memory_update_enabled"]
+        end
+
+        @agent_config.save
+        json_response(res, 200, { ok: true })
+      rescue => e
+        json_response(res, 422, { error: e.message })
+      end
+
       # POST /api/config — save updated model list
       # DEPRECATED: this endpoint previously accepted the entire models array
       # and replaced @models in place. That design was fragile — any missing
@@ -3239,8 +3719,8 @@ module Clacky
         # fine and no longer blocks the disk cleanup below.
         @registry.delete(session_id) if in_registry
 
-        # Always physically remove the persisted session file (+ chunks).
-        @session_manager.delete(session_id) if on_disk
+        # 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).
@@ -3459,9 +3939,16 @@ module Clacky
         # If session is running, interrupt it first (mimics CLI behavior)
         if session[:status] == :running
           interrupt_session(session_id)
-          # Wait briefly for the thread to catch the interrupt and update status
-          # This ensures the agent loop exits cleanly before starting the new task
-          sleep 0.1
+
+          # Give the old thread a short window to exit cleanly.
+          # In the common case it returns within milliseconds (Thread#raise
+          # lands on a tight loop or LLM read). If it can't be reached in
+          # time (e.g. blocked in a slow subagent syscall), we proceed anyway:
+          # the agent's check_stale! checkpoints will refuse to mutate
+          # history once the new thread takes over.
+          old_thread = nil
+          @registry.with_session(session_id) { |s| old_thread = s[:thread] }
+          old_thread&.join(2)
         end
 
         agent = nil
@@ -3621,6 +4108,23 @@ module Clacky
         run_agent_task(session_id, agent) { agent.run(prompt) }
       end
 
+      # Interrupt every running agent thread and persist its session state.
+      private def interrupt_all_agents
+        return unless @registry && @session_manager
+
+        @registry.each_live_agent do |id, agent, thread|
+          next unless thread&.alive?
+          begin
+            thread.raise(Clacky::AgentInterrupted, "Worker shutting down")
+            Clacky::Logger.info("[shutdown] interrupted session=#{id}")
+          rescue => e
+            Clacky::Logger.error("[shutdown] interrupt failed for session=#{id}: #{e.message}")
+          end
+          thread.join(2)
+          @session_manager.save(agent.to_session_data(status: :interrupted))
+        end
+      end
+
       # Run an agent task in a background thread, handling status updates,
       # session persistence, and idle compression timer lifecycle.
       # Yields to the caller to perform the actual agent.run call.
@@ -3742,7 +4246,7 @@ module Clacky
       # ── Helpers ───────────────────────────────────────────────────────────────
 
       def default_working_dir
-        File.expand_path("~/clacky_workspace")
+        @agent_config&.default_working_dir || File.expand_path("~/clacky_workspace")
       end
 
       # Create a session in the registry and wire up Agent + WebUIController.