openclacky 1.0.2 → 1.0.4

data/lib/clacky/server/epipe_safe_io.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module Clacky
+  module Server
+    # EPIPESafeIO — wraps an IO ($stdout / $stderr) so that writes never raise
+    # Errno::EPIPE / IOError to the calling code.
+    #
+    # Why this exists:
+    #   The server worker process inherits fd 0/1/2 from the Master. If the
+    #   Master itself was launched in a way where its stdout/stderr eventually
+    #   becomes a broken pipe (e.g. launched by an installer that exits, or by
+    #   a GUI/IDE process that closes its end), the worker's first `puts` after
+    #   that pipe breaks raises Errno::EPIPE. Unhandled, this kills the worker
+    #   — taking all in-memory sessions, agent loops, and SSE connections down
+    #   with it, and triggering a crash loop because the new worker inherits
+    #   the same broken fd.
+    #
+    # Behavior:
+    #   - Healthy state: delegates every method to the underlying IO. Users
+    #     see normal terminal output (banner, request logs, etc.).
+    #   - First broken-pipe failure: catches Errno::EPIPE / IOError, swaps
+    #     the underlying IO to /dev/null permanently, and returns silently.
+    #     Subsequent writes succeed (into /dev/null) so the worker stays alive.
+    #   - Session state, agent loops, SSE connections all preserved.
+    #
+    # Scope:
+    #   We only wrap $stdout / $stderr (the global variables that Kernel#puts,
+    #   Kernel#print, Kernel#warn, etc. use under the hood). We do NOT touch
+    #   the STDOUT / STDERR constants — a codebase audit confirmed nothing in
+    #   Clacky writes to those constants directly (only `STDOUT.flush` which
+    #   cannot raise EPIPE).
+    class EPIPESafeIO < SimpleDelegator
+      # Methods that perform writes and may raise Errno::EPIPE.
+      # We override each one to rescue and degrade gracefully.
+      WRITE_METHODS = %i[write write_nonblock syswrite puts print printf << putc].freeze
+
+      WRITE_METHODS.each do |m|
+        define_method(m) do |*args, **kwargs, &blk|
+          if kwargs.empty?
+            __getobj__.public_send(m, *args, &blk)
+          else
+            __getobj__.public_send(m, *args, **kwargs, &blk)
+          end
+        rescue Errno::EPIPE, IOError => e
+          fall_back_to_null!(e)
+          # Retry the write into /dev/null so semantics (return value type) stay
+          # close to what the caller expects. If even this fails, swallow it —
+          # we must not raise from inside a write to $stdout/$stderr.
+          begin
+            if kwargs.empty?
+              __getobj__.public_send(m, *args, &blk)
+            else
+              __getobj__.public_send(m, *args, **kwargs, &blk)
+            end
+          rescue StandardError
+            nil
+          end
+        end
+      end
+
+      # Some callers do `$stdout.flush`. Make it safe too.
+      def flush
+        __getobj__.flush
+      rescue Errno::EPIPE, IOError => e
+        fall_back_to_null!(e)
+        nil
+      end
+
+      # Whether this wrapper has already fallen back to /dev/null.
+      # Useful for tests and diagnostics.
+      def fell_back?
+        @fell_back == true
+      end
+
+      private def fall_back_to_null!(error)
+        return if @fell_back
+
+        @fell_back = true
+        begin
+          # Best-effort: try to log once via Clacky::Logger if available.
+          # Wrapped in rescue because Logger itself might be mid-init.
+          if defined?(Clacky::Logger)
+            Clacky::Logger.warn(
+              "[EPIPESafeIO] Underlying IO broken (#{error.class}: #{error.message}); " \
+              "falling back to /dev/null. Worker stays alive."
+            )
+          end
+        rescue StandardError
+          # ignore
+        end
+
+        begin
+          null = File.open(File::NULL, "w")
+          null.sync = true
+          __setobj__(null)
+        rescue StandardError
+          # If even opening /dev/null fails, leave the original object — at
+          # worst the next write raises again and we rescue again.
+        end
+      end
+    end
+  end
+end

data/lib/clacky/server/http_server.rb

@@ -57,7 +57,9 @@ module Clacky
       def show_assistant_message(content, files:)
         return if content.nil? || content.to_s.strip.empty?
 
-        @events << { type: "assistant_message", session_id: @session_id, content: content }
+        # Rewrite local image paths to /api/local-image proxy URLs for browser rendering
+        rewritten = Utils::FileProcessor.rewrite_local_image_urls(content.to_s)
+        @events << { type: "assistant_message", session_id: @session_id, content: rewritten }
       end
 
       def show_tool_call(name, args)
@@ -203,15 +205,6 @@ module Clacky
 
         Clacky::Logger.info("[HttpServer PID=#{Process.pid}] start() mode=#{@inherited_socket ? 'worker' : 'standalone'} inherited_socket=#{@inherited_socket.inspect} master_pid=#{@master_pid.inspect}")
 
-        # In standalone mode (no master), kill any stale server and manage our own PID file.
-        # In worker mode the master owns the PID file; we just skip this block.
-        if @inherited_socket.nil?
-          kill_existing_server(@port)
-          pid_file = File.join(Dir.tmpdir, "clacky-server-#{@port}.pid")
-          File.write(pid_file, Process.pid.to_s)
-          at_exit { File.delete(pid_file) if File.exist?(pid_file) }
-        end
-
         # Expose server address and brand name to all child processes (skill scripts, shell commands, etc.)
         # so they can call back into the server without hardcoding the port,
         # and use the correct product name without re-reading brand.yml.
@@ -406,13 +399,20 @@ module Clacky
         when ["POST",   "/api/tool/browser"]      then api_tool_browser(req, res)
         when ["POST",   "/api/upload"]            then api_upload_file(req, res)
         when ["POST",   "/api/open-file"]         then api_open_file(req, res)
+        when ["GET",    "/api/local-image"]       then api_serve_local_image(req, res)
         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 ["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
-          if method == "POST" && path.match?(%r{^/api/channels/[^/]+/test$})
+          if method == "POST" && path.match?(%r{^/api/channels/[^/]+/send$})
+            platform = path.sub("/api/channels/", "").sub("/send", "")
+            api_send_channel_message(platform, req, res)
+          elsif method == "GET" && path.match?(%r{^/api/channels/[^/]+/users$})
+            platform = path.sub("/api/channels/", "").sub("/users", "")
+            api_list_channel_users(platform, res)
+          elsif method == "POST" && path.match?(%r{^/api/channels/[^/]+/test$})
             platform = path.sub("/api/channels/", "").sub("/test", "")
             api_test_channel(platform, req, res)
           elsif method == "POST" && path.start_with?("/api/channels/")
@@ -1439,6 +1439,79 @@ module Clacky
         json_response(res, 200, { channels: platforms })
       end
 
+      # POST /api/channels/:platform/send
+      # Proactively send a message to a user via the given IM platform.
+      #
+      # Body:
+      #   { "message": "hello",            # required
+      #     "user_id": "some_user_id" }    # optional — defaults to most-recently active user
+      #
+      # Response:
+      #   200 { ok: true }
+      #   400 { ok: false, error: "..." }  — missing/invalid params or platform not running
+      #   503 { ok: false, error: "..." }  — no known users (nobody has messaged the bot yet)
+      #
+      # Constraints:
+      #   - The platform adapter must be running (channel must be enabled + connected).
+      #   - For Weixin (iLink protocol), a context_token is required per message. This is
+      #     automatically looked up from the in-memory cache populated by inbound messages.
+      #     If no token exists for the target user (i.e. the user has never messaged the bot
+      #     in this server session), the message cannot be delivered.
+      def api_send_channel_message(platform, req, res)
+        platform = platform.to_sym
+        body     = parse_json_body(req)
+        message  = body["message"].to_s.strip
+
+        if message.empty?
+          json_response(res, 400, { ok: false, error: "message is required" })
+          return
+        end
+
+        # Resolve target user_id
+        user_id = body["user_id"].to_s.strip
+        if user_id.empty?
+          # Default to the most-recently active user for this platform
+          known = @channel_manager.known_users(platform)
+          if known.empty?
+            json_response(res, 503, {
+              ok:    false,
+              error: "No known users for :#{platform}. The user must send a message to the bot first."
+            })
+            return
+          end
+          user_id = known.last
+        end
+
+        result = @channel_manager.send_to_user(platform, user_id, message)
+        if result.nil?
+          json_response(res, 400, {
+            ok:    false,
+            error: "Failed to send message. The :#{platform} adapter may not be running, or no context_token is available for user #{user_id}."
+          })
+        else
+          json_response(res, 200, { ok: true, platform: platform, user_id: user_id })
+        end
+      rescue StandardError => e
+        json_response(res, 500, { ok: false, error: e.message })
+      end
+
+      # GET /api/channels/:platform/users
+      # Returns the list of known user IDs for the given platform.
+      # These are users who have sent at least one message to the bot in this server session.
+      #
+      # For Weixin: returns users with a cached context_token (required for proactive messaging).
+      # For Feishu / WeCom: returns user IDs extracted from channel session bindings.
+      #
+      # Response:
+      #   200 { users: ["uid1", "uid2", ...] }
+      def api_list_channel_users(platform, res)
+        platform = platform.to_sym
+        users    = @channel_manager.known_users(platform)
+        json_response(res, 200, { platform: platform, users: users })
+      rescue StandardError => e
+        json_response(res, 500, { ok: false, error: e.message })
+      end
+
       # POST /api/upload
       # Accepts a multipart/form-data file upload (field name: "file").
       # Runs the file through FileProcessor: saves original + generates structured
@@ -1485,6 +1558,43 @@ module Clacky
         json_response(res, 500, { ok: false, error: e.message })
       end
 
+      # GET /api/local-image?path=file:///path/to/image.png
+      # GET /api/local-image?path=/path/to/image.png
+      #
+      # Serves a local image file with the correct Content-Type.
+      # Used by the Web UI to render local images that would otherwise be blocked
+      # by the browser's security policy (file:// from http:// origin).
+      #
+      def api_serve_local_image(req, res)
+        raw_path = URI.decode_www_form(req.query_string.to_s).to_h["path"].to_s
+        return json_response(res, 400, { error: "path is required" }) if raw_path.empty?
+
+        # Strip file:// prefix if present
+        path = raw_path.sub(%r{\Afile://}, "")
+        path = CGI.unescape(path)
+        path = File.expand_path(path)
+
+        # On WSL the file may be specified as a Windows path (e.g. "C:/Users/…").
+        # Convert it to the Linux-side path so File.exist? works.
+        path = Utils::EnvironmentDetector.win_to_linux_path(path)
+
+        # Security: only serve image files
+        ext = File.extname(path).downcase
+        unless Utils::FileProcessor::LOCAL_IMAGE_EXTENSIONS.include?(ext)
+          return json_response(res, 403, { error: "not an image file" })
+        end
+
+        return json_response(res, 404, { error: "file not found" }) unless File.exist?(path)
+
+        mime = Utils::FileProcessor::MIME_TYPES[ext] || "application/octet-stream"
+        res.status         = 200
+        res["Content-Type"] = mime
+        res["Cache-Control"] = "private, max-age=3600"
+        res.body = File.binread(path)
+      rescue => e
+        json_response(res, 500, { error: e.message })
+      end
+
       # POST /api/channels/:platform
       # Body: { fields... }  (platform-specific credential fields)
       # Saves credentials and optionally (re)starts the adapter.
@@ -3648,36 +3758,6 @@ module Clacky
         res.body   = "Not Found"
       end
 
-      # Stop any previously running server on the given port via its PID file.
-      private def kill_existing_server(port)
-        pid_file = File.join(Dir.tmpdir, "clacky-server-#{port}.pid")
-        return unless File.exist?(pid_file)
-
-        pid = File.read(pid_file).strip.to_i
-        return if pid <= 0
-        # After exec-restart, the new process inherits the same PID as the old one.
-        # Skip sending TERM to ourselves — we are already the new server.
-        if pid == Process.pid
-          Clacky::Logger.info("[Server] exec-restart detected (PID=#{pid}), skipping self-kill.")
-          return
-        end
-
-        begin
-          Process.kill("TERM", pid)
-          Clacky::Logger.info("[Server] Stopped existing server (PID=#{pid}) on port #{port}.")
-          puts "Stopped existing server (PID: #{pid}) on port #{port}."
-          # Give it a moment to release the port
-          sleep 0.5
-        rescue Errno::ESRCH
-          Clacky::Logger.info("[Server] Existing server PID=#{pid} already gone.")
-        rescue Errno::EPERM
-          Clacky::Logger.warn("[Server] Could not stop existing server (PID=#{pid}) — permission denied.")
-          puts "Could not stop existing server (PID: #{pid}) — permission denied."
-        ensure
-          File.delete(pid_file) if File.exist?(pid_file)
-        end
-      end
-
       # ── Inner classes ─────────────────────────────────────────────────────────
 
       # Wraps a raw TCP socket, providing thread-safe WebSocket frame sending.

data/lib/clacky/server/server_master.rb

@@ -143,10 +143,16 @@ module Clacky
 
         Clacky::Logger.info("[Master PID=#{Process.pid}] spawn: #{ruby} #{script} #{worker_argv.join(' ')}")
         Clacky::Logger.info("[Master PID=#{Process.pid}] env: #{env.inspect}")
+
         # pgroup: 0 puts worker in its own process group.
         # This lets Master send TERM/KILL to the entire group (-pid) on shutdown,
         # ensuring grandchildren (e.g. chrome-devtools-mcp node process) are also
         # cleaned up even if the worker is force-killed before its shutdown_proc runs.
+        #
+        # NOTE on stdio: we deliberately let the worker inherit Master's fd 0/1/2
+        # so users see startup banner / request logs in their terminal. Protection
+        # against Errno::EPIPE on broken parent stdout is installed inside the
+        # worker itself (see cli.rb worker entry — EPIPESafeIO wrapper).
         pid = spawn(env, ruby, script, *worker_argv, pgroup: 0)
         Clacky::Logger.info("[Master PID=#{Process.pid}] Spawned worker PID=#{pid} pgroup=#{pid}")
         pid

data/lib/clacky/skill.rb

@@ -287,6 +287,36 @@ module Clacky
         end
       end
 
+      # Environment hint: if the skill references ${CLACKY_SERVER_HOST/PORT} but
+      # those vars were not injected (bare-CLI mode without a running server),
+      # the `${...}` placeholders will survive expansion as literal text. In that
+      # case append a non-fatal note so the LLM knows the skill's HTTP callbacks
+      # will not work, without blocking the skill entirely (the user may still
+      # want to read instructions, explore files, etc.).
+      if processed_content.match?(/\$\{CLACKY_SERVER_(HOST|PORT)\}/)
+        processed_content += <<~HINT
+
+
+          ---
+
+          > ⚠️ **Environment note (auto-injected)**: this skill calls back into the
+          > Clacky HTTP server (via `${CLACKY_SERVER_HOST}` / `${CLACKY_SERVER_PORT}`),
+          > but those variables are **not set** in the current process. That means
+          > no local Clacky server was detected.
+          >
+          > Any `curl http://${CLACKY_SERVER_HOST}:...` command in the steps above
+          > will fail with a DNS/connection error. Before running those steps you
+          > should either:
+          >
+          > 1. Ask the user to start the server in another terminal: `clacky server`
+          >    (then retry — the CLI auto-detects it via `/tmp/clacky-master-*.pid`), or
+          > 2. If the task can be completed without the server API, skip those steps
+          >    and tell the user which parts require the server.
+          >
+          > This is an informational hint, not an error. Proceed with judgment.
+        HINT
+      end
+
       processed_content
     end
 

data/lib/clacky/utils/file_processor.rb

@@ -523,8 +523,79 @@ module Clacky
       nil
     end
 
+    # Image extensions that can be inlined as data URLs in markdown content.
+    LOCAL_IMAGE_EXTENSIONS = %w[.png .jpg .jpeg .gif .webp].freeze
+
+    # Replace local image paths in markdown content with base64 data URLs.
+    #
+    # Handles both `file:///path/to/img.png` and bare `/path/to/img.png` in
+    # markdown image syntax `![alt](src)`.
+    #
+    # @param content [String] markdown text potentially containing local image references
+    # @return [String] content with local images replaced by data URLs
+    def self.inline_local_images(content)
+      return content if content.nil? || content.empty?
+
+      content.gsub(%r{(!\[[^\]]*\])\((file://)?(/[^)]+)\)}) do
+        prefix     = $1
+        _scheme    = $2
+        raw_path   = $3
+        path       = CGI.unescape(raw_path)
+        ext        = File.extname(path).downcase
+        full_match = $&
+
+        unless LOCAL_IMAGE_EXTENSIONS.include?(ext) && File.exist?(path)
+          next full_match
+        end
+
+        begin
+          data_url = image_path_to_data_url(path)
+          Clacky::Logger.info("file_processor.inline_local_images", path: path, size: File.size(path))
+          "#{prefix}(#{data_url})"
+        rescue StandardError => e
+          Clacky::Logger.warn("file_processor.inline_local_images.failed", path: path, error: e.message)
+          full_match
+        end
+      end
+    end
+
     private_class_method :parse_zip_listing, :parse_tar_listing, :save_preview, :sanitize_filename,
                          :downscale_png_chunky, :downscale_via_cli
+
+    # -------------------------------------------------------------------------
+    # Local image URL rewriting
+    # -------------------------------------------------------------------------
+
+    # Rewrite local image paths in markdown content to use the /api/local-image proxy.
+    #
+    # Matches two patterns inside `![alt](url)`:
+    #   1. file:// URLs  →  ![alt](/api/local-image?path=file:///abs/path.png)
+    #   2. bare absolute paths  →  ![alt](/api/local-image?path=/abs/path.png)
+    #
+    # https:// URLs and non-image files are left untouched.
+    #
+    # @param content [String, nil] markdown text
+    # @return [String, nil] rewritten content (or original if nothing matched)
+    def self.rewrite_local_image_urls(content)
+      return content if content.nil? || content.empty?
+
+      content.gsub(/!\[([^\]]*)\]\(((?:file:\/\/)?\/[^)]+)\)/) do |match|
+        alt  = Regexp.last_match(1)
+        href = Regexp.last_match(2)
+
+        # Extract the filesystem path from the href
+        path = href.sub(%r{\Afile://}, "")
+        path = CGI.unescape(path)
+
+        ext = File.extname(path).downcase
+        if LOCAL_IMAGE_EXTENSIONS.include?(ext) && File.exist?(path)
+          encoded = CGI.escape(href)
+          "![#{alt}](/api/local-image?path=#{encoded})"
+        else
+          match # return original match unchanged
+        end
+      end
+    end
   end
   end
 end

data/lib/clacky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clacky
-  VERSION = "1.0.2"
+  VERSION = "1.0.4"
 end

data/lib/clacky/web/app.css

@@ -854,69 +854,106 @@ body {
   display: none;
   align-items: center;
   justify-content: center;
-  width: 18px;
-  height: 18px;
+  width: 24px;
+  height: 24px;
   background: transparent;
   border: none;
-  border-radius: 3px;
+  border-radius: 4px;
   color: var(--color-text-muted);
-  font-size: 14px;
-  line-height: 1;
   cursor: pointer;
   padding: 0;
-  margin-top: -3px;
   transition: background .15s, color .15s;
-  font-weight: bold;
-  letter-spacing: -1px;
+  align-self: center;
 }
 .session-item:hover .session-actions-btn { display: flex; }
 .session-actions-btn:hover { 
-  background: var(--color-bg-hover); 
+  background: var(--color-border-primary); 
   color: var(--color-text-primary); 
 }
 
 /* Pin icon in session name */
 .session-pin-icon {
   flex-shrink: 0;
-  font-size: 11px;
-  opacity: 0.7;
+  display: inline-flex;
+  align-items: center;
+  opacity: 0.6;
   margin-left: 2px;
+  color: var(--color-text-tertiary);
 }
 .session-item.active .session-pin-icon {
   opacity: 1;
+  color: var(--color-accent-primary);
 }
 
 /* Actions menu dropdown */
 .session-actions-menu {
   background: var(--color-bg-secondary);
   border: 1px solid var(--color-border-primary);
-  border-radius: 6px;
-  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
-  padding: 3px;
-  min-width: 120px;
+  border-radius: 8px;
+  box-shadow: 0 6px 20px rgba(0, 0, 0, 0.08), 0 2px 6px rgba(0, 0, 0, 0.04);
+  padding: 4px;
+  min-width: 160px;
   z-index: 1000;
   animation: fadeIn 0.15s ease;
 }
 [data-theme="dark"] .session-actions-menu {
-  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.4);
+  box-shadow: 0 8px 24px rgba(0, 0, 0, 0.5), 0 2px 6px rgba(0, 0, 0, 0.3);
 }
 .session-actions-menu-item {
+  display: flex;
+  align-items: center;
+  gap: 8px;
   padding: 6px 10px;
-  border-radius: 4px;
+  border-radius: 5px;
   cursor: pointer;
   color: var(--color-text-primary);
-  font-size: 12px;
-  transition: background .15s;
+  font-size: 13px;
+  line-height: 1.4;
+  transition: background .12s ease, color .12s ease;
   user-select: none;
 }
+.session-actions-menu-icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 14px;
+  height: 14px;
+  color: var(--color-text-secondary);
+  flex-shrink: 0;
+}
+.session-actions-menu-label {
+  flex: 1;
+  min-width: 0;
+}
 .session-actions-menu-item:hover {
   background: var(--color-bg-hover);
 }
+.session-actions-menu-item:hover .session-actions-menu-icon {
+  color: var(--color-text-primary);
+}
+.session-actions-menu-item--danger .session-actions-menu-icon {
+  color: var(--color-text-secondary);
+}
 .session-actions-menu-item--danger {
-  color: var(--color-error);
+  margin-top: 5px;
+  position: relative;
+}
+.session-actions-menu-item--danger::before {
+  content: "";
+  position: absolute;
+  left: 0;
+  right: 0;
+  top: -3px;
+  height: 1px;
+  background: var(--color-border-secondary);
+  pointer-events: none;
 }
 .session-actions-menu-item--danger:hover {
   background: var(--color-error-bg);
+  color: var(--color-error);
+}
+.session-actions-menu-item--danger:hover .session-actions-menu-icon {
+  color: var(--color-error);
 }
 
 @keyframes fadeIn {
@@ -1557,7 +1594,7 @@ body {
 .msg-user .msg-time      { color: var(--color-text-secondary); right: 0; left: auto; padding-right: 4px; }
 .msg-assistant .msg-time { color: var(--color-text-secondary); left: 0;  right: auto; padding-left: 4px; }
 
-.msg-user      { background: var(--color-accent-primary); color: var(--color-button-primary-text); align-self: flex-end; }
+.msg-user      { background: var(--color-accent-primary); color: var(--color-button-primary-text); align-self: flex-end; white-space: pre-wrap; }
 [data-theme="dark"] .msg-user { background: var(--color-accent-hover); }
 .msg-assistant { background: var(--color-bg-tertiary); border: 1px solid var(--color-border-primary); align-self: flex-start; }
 
@@ -1610,7 +1647,6 @@ body {
 }
 
 /* ── Markdown rendering inside assistant messages ────────────────────────── */
-.msg-assistant p          { margin: 0 0 0.6em; }
 .msg-assistant p:last-child { margin-bottom: 0; }
 .msg-assistant h1, .msg-assistant h2, .msg-assistant h3,
 .msg-assistant h4, .msg-assistant h5, .msg-assistant h6 {

data/lib/clacky/web/i18n.js

@@ -43,11 +43,13 @@ const I18n = (() => {
       "chat.history_load_failed": "Could not load history",
       "chat.history_start":       "No more history",
       "chat.image_expired": "Expired",
-      "chat.done":           "Done — {{n}} iteration(s), ${{cost}}",
+      "chat.done":           "Done — {{n}} iteration(s), {{cost}}",
       "chat.interrupted":    "Interrupted.",
       "chat.feedback_hint":  "Or type your own answer below ↓",
       "chat.newMessageHint": "New messages ↓",
       "chat.retry":          "Retry",
+      "chat.resetSession":   "Reset session",
+      "chat.resetSessionConfirm": "Reset will start a brand-new session. The current conversation history stays in your sidebar but will no longer be active. Continue?",
       "chat.copy":           "Copy",
       "chat.copied":         "Copied",
       "chat.empty.title":    "Start the conversation",
@@ -541,7 +543,7 @@ const I18n = (() => {
       "chat.history_load_failed": "历史记录加载失败",
       "chat.history_start":       "没有更多历史了",
       "chat.image_expired": "已过期",
-      "chat.done":           "完成 — {{n}} 步，${{cost}}",
+      "chat.done":           "完成 — {{n}} 步，{{cost}}",
       "chat.interrupted":    "已中断。",
       "chat.feedback_hint":  "或在下方输入框自由作答 ↓",
       "chat.newMessageHint": "有新消息 ↓",