openclacky 1.2.13 → 1.2.15

data/lib/clacky/server/http_server.rb

@@ -40,15 +40,13 @@ module Clacky
           url  = f[:data_url] || f["data_url"]
           name = f[:name]     || f["name"]
           path = f[:path]     || f["path"]
+          type = f[:type]     || f["type"] || ""
 
           if url
             url
-          elsif path && File.exist?(path.to_s)
-            # Reconstruct data_url from the tmp file (still present on disk)
+          elsif type.to_s == "image" && path && File.exist?(path.to_s)
             Utils::FileProcessor.image_path_to_data_url(path) rescue "expired:#{name}"
           elsif name
-            # File badge for non-image disk files, or image whose tmp file is gone
-            type = f[:type] || f["type"] || ""
             type.to_s == "image" ? "expired:#{name}" : "pdf:#{name}"
           end
         end
@@ -440,6 +438,10 @@ module Clacky
         when ["POST",   "/api/config/test"]   then api_test_config(req, res)
         when ["POST",   "/api/config/media/test"] then api_test_media_config(req, res)
         when ["GET",    "/api/config/media"]  then api_get_media_config(res)
+        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 ["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)
         when ["GET",    "/api/browser/status"]    then api_browser_status(res)
@@ -1103,6 +1105,179 @@ module Clacky
         json_response(res, 422, { error: e.message })
       end
 
+      # GET /api/config/ocr
+      # Returns the OCR sidecar state for the Settings UI. Mirrors media_state
+      # in shape so the UI can render OCR with the same row component.
+      def api_get_ocr_config(res)
+        state = @agent_config.ocr_state
+        entry = @agent_config.find_model_by_type("ocr")
+
+        out = {
+          source:         state["source"],
+          model:          state["model"],
+          base_url:       state["base_url"],
+          api_key_masked: entry ? mask_api_key(entry["api_key"]) : nil,
+          provider:       state["provider"],
+          available:      state["available"],
+          stale:          state["stale"] || false,
+          requested_model: state["requested_model"],
+          configured:     state["configured"],
+          primary:        state["primary"] || false
+        }
+
+        # Auto-mode preview: surface what the OCR sidecar *would* be if the
+        # user flipped to "auto" — derived from the same provider as the
+        # current default model.
+        default = @agent_config.find_model_by_type("default")
+        provider_id = default && Clacky::Providers.resolve_provider(
+          base_url: default["base_url"],
+          api_key:  default["api_key"]
+        )
+        default_preview = {
+          provider:  provider_id,
+          model:     provider_id ? Clacky::Providers.default_ocr_model(provider_id) : nil,
+          available: provider_id ? Clacky::Providers.ocr_models(provider_id) : []
+        }
+
+        json_response(res, 200, { ocr: out, default_provider: default_preview })
+      end
+
+      # PATCH /api/config/ocr
+      # Body: { source: "off"|"auto"|"custom", model?, base_url?, api_key?,
+      #         anthropic_format? }
+      # Mirrors api_update_media_config but for the single "ocr" type.
+      def api_update_ocr_config(req, res)
+        body = parse_json_body(req) || {}
+        source = body["source"].to_s
+        unless %w[off auto custom].include?(source)
+          return json_response(res, 422, { error: "invalid source" })
+        end
+
+        @agent_config.models.reject! { |m| m["type"] == "ocr" }
+
+        case source
+        when "off"
+          @agent_config.models << {
+            "id"       => SecureRandom.uuid,
+            "type"     => "ocr",
+            "disabled" => true
+          }
+        when "auto"
+          override = body["model"].to_s.strip
+          unless override.empty?
+            @agent_config.models << {
+              "id"    => SecureRandom.uuid,
+              "type"  => "ocr",
+              "model" => override
+            }
+          end
+        when "custom"
+          model    = body["model"].to_s.strip
+          base_url = body["base_url"].to_s.strip
+          api_key  = body["api_key"].to_s
+          if api_key.include?("****")
+            existing = @agent_config.models.find { |m| m["type"] == "ocr" && m["api_key"] }
+            api_key = existing ? existing["api_key"].to_s : ""
+          end
+          if model.empty? || base_url.empty? || api_key.empty?
+            return json_response(res, 422, { error: "model, base_url, api_key are required" })
+          end
+
+          @agent_config.models << {
+            "id"               => SecureRandom.uuid,
+            "model"            => model,
+            "base_url"         => base_url,
+            "api_key"          => api_key,
+            "anthropic_format" => body["anthropic_format"] || false,
+            "type"             => "ocr"
+          }
+        end
+
+        @agent_config.save
+        json_response(res, 200, { ok: true, state: @agent_config.ocr_state })
+      rescue => e
+        json_response(res, 422, { error: e.message })
+      end
+
+      # POST /api/config/ocr/test
+      # Reuses the media preflight (GET /models) — same connectivity check.
+      def api_test_ocr_config(req, res)
+        body = parse_json_body(req) || {}
+        api_key = body["api_key"].to_s
+        if api_key.empty? || api_key.include?("****")
+          existing = @agent_config.find_model_by_type("ocr") || {}
+          api_key = existing["api_key"].to_s
+        end
+
+        model    = body["model"].to_s.strip
+        base_url = body["base_url"].to_s.strip
+
+        if model.empty? || base_url.empty? || api_key.empty?
+          return json_response(res, 200, { ok: false, message: "model, base_url, api_key are required" })
+        end
+
+        result = preflight_media_endpoint(base_url: base_url, api_key: api_key, model: model)
+        json_response(res, 200, result)
+      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-
+      # only by virtue of the standard auth path: when the server binds to
+      # 127.0.0.1 (@localhost_only), check_access_key returns true without
+      # requiring a token, so parsers running on the same host can call this
+      # endpoint with no extra wiring.
+      #
+      # Request:  multipart/form-data with field "image" (binary), optional "prompt"
+      #           OR JSON body { "data_url": "data:image/png;base64,...", "prompt": "..." }
+      # Response: { ok: true, text: "..." } or { ok: false, message: "..." }
+      def api_internal_ocr_image(req, res)
+        entry = @agent_config.find_model_by_type("ocr")
+        unless entry
+          return json_response(res, 503, { ok: false, message: "OCR sidecar not configured" })
+        end
+
+        prompt   = nil
+        data_url = nil
+        bytes    = nil
+        mime     = "image/png"
+
+        ctype = req.content_type.to_s
+        if ctype.start_with?("multipart/form-data")
+          parts = req.query
+          if (img = parts["image"])
+            bytes = img.respond_to?(:read) ? img.read : img.to_s
+            mime  = (img.respond_to?(:[]) ? img["content-type"].to_s : nil)
+            mime  = "image/png" if mime.nil? || mime.empty?
+          end
+          prompt = parts["prompt"].to_s if parts["prompt"]
+        else
+          body = parse_json_body(req) || {}
+          data_url = body["data_url"].to_s
+          prompt   = body["prompt"].to_s if body["prompt"]
+        end
+
+        image =
+          if bytes && !bytes.empty?
+            { bytes: bytes, mime_type: mime }
+          elsif data_url && !data_url.empty?
+            { data_url: data_url }
+          else
+            return json_response(res, 400, { ok: false, message: "image or data_url required" })
+          end
+
+        text = Clacky::Vision::Resolver.new(entry).describe(image, prompt: prompt)
+        if text && !text.strip.empty?
+          json_response(res, 200, { ok: true, text: text })
+        else
+          json_response(res, 200, { ok: false, message: "OCR returned empty result" })
+        end
+      rescue => e
+        json_response(res, 500, { ok: false, message: e.message })
+      end
+
       # POST /api/onboard/complete
       # Called after key setup is done (soul_setup is optional/skipped).
       # Creates the default session if none exists yet, returns it.
@@ -3742,7 +3917,8 @@ module Clacky
           ok: true,
           enable_compression: @agent_config.enable_compression,
           enable_prompt_caching: @agent_config.enable_prompt_caching,
-          memory_update_enabled: @agent_config.memory_update_enabled
+          memory_update_enabled: @agent_config.memory_update_enabled,
+          proxy_url: @agent_config.proxy_url.to_s
         })
       end
 
@@ -3760,6 +3936,22 @@ module Clacky
         if body.key?("memory_update_enabled")
           @agent_config.memory_update_enabled = !!body["memory_update_enabled"]
         end
+        if body.key?("proxy_url")
+          raw = body["proxy_url"].to_s.strip
+          if raw.empty?
+            @agent_config.proxy_url = nil
+          else
+            begin
+              uri = URI.parse(raw)
+              unless uri.is_a?(URI::HTTP) && uri.host && !uri.host.empty?
+                return json_response(res, 422, { error: "proxy_url must be a valid http(s) URL" })
+              end
+            rescue URI::InvalidURIError
+              return json_response(res, 422, { error: "proxy_url is not a valid URL" })
+            end
+            @agent_config.proxy_url = raw
+          end
+        end
 
         @agent_config.save
         json_response(res, 200, { ok: true })
@@ -4778,6 +4970,11 @@ module Clacky
           task.call
           @registry.update(session_id, status: :idle, error: nil)
           broadcast_session_update(session_id)
+          # Transient global signal for the optional task-complete sound. Sent to
+          # all clients (broadcast_all) so a browser viewing another session — or
+          # 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))
           # Start idle compression timer now that the agent is idle
           idle_timer&.start

data/lib/clacky/server/scheduler.rb

@@ -192,17 +192,20 @@ module Clacky
 
       private def run_loop
         loop do
-          break unless @running
-
-          tick(Time.now)
-
-          # Sleep until the start of the next minute
-          now     = Time.now
-          sleep_s = 60 - now.sec
-          sleep(sleep_s)
+          begin
+            break unless @running
+
+            tick(Time.now)
+
+            # Sleep until the start of the next minute
+            now     = Time.now
+            sleep_s = 60 - now.sec
+            sleep(sleep_s)
+          rescue => e
+            Clacky::Logger.error("scheduler_tick_error", error: e)
+            sleep(5) # back off before retrying next tick
+          end
         end
-      rescue => e
-        Clacky::Logger.error("scheduler_fatal_error", error: e)
       end
 
       # Check all enabled schedules against the given time and fire matching ones.

data/lib/clacky/ui2/progress_handle.rb

@@ -127,6 +127,7 @@ module Clacky
         @start_time    = nil
         @ticker        = nil
         @state         = :fresh     # :fresh → :running → :closed
+        @unregistered  = false
         @metadata      = {}
         @last_chunk_at = nil
         @monitor       = Monitor.new
@@ -172,34 +173,37 @@ module Clacky
       end
 
       # Stop the ticker, render one final frame, and unregister from the
-      # owner. Idempotent — calling twice is a no-op.
+      # owner. Idempotent and crash-safe — if a previous finish was
+      # interrupted (e.g. Thread#raise(AgentInterrupted) hit between
+      # +stop_ticker+ and +unregister_progress+), a follow-up finish
+      # will still complete the unregister so the handle does not stay
+      # orphaned on the owner's progress stack.
       #
       # @param final_message [String, nil] Optional override for the last
       #   frame. If nil, the handle composes "<message>… (<elapsed>s)".
       def finish(final_message: nil)
-        Clacky::Logger.warn("[ph_debug] finish_entry", oid: object_id, state: @state, msg: @message, eid: @entry_id)
+        Clacky::Logger.warn("[ph_debug] finish_entry", oid: object_id, state: @state, unreg: @unregistered, msg: @message, eid: @entry_id)
         snapshot = @monitor.synchronize do
-          if @state != :running
-            Clacky::Logger.warn("[ph_debug] finish_noop_state", oid: object_id, state: @state)
-            return
-          end
-          @state = :closed
-          { message: final_message || @message, elapsed: elapsed_seconds }
+          return if @unregistered
+          first_close = @state == :running
+          @state = :closed if first_close
+          {
+            first_close: first_close,
+            message: final_message || @message,
+            elapsed: elapsed_seconds,
+          }
         end
 
         stop_ticker
-        # Collapse fast-finishers to a removed entry so tools that complete
-        # in under FAST_FINISH_THRESHOLD_SECONDS don't leave a permanent
-        # "Executing foo… (0s)" line. The owner interprets final_frame: nil
-        # as "remove the entry entirely".
         final_frame =
           if @quiet_on_fast_finish && snapshot[:elapsed] < FAST_FINISH_THRESHOLD_SECONDS
             nil
           else
             compose_final_frame(snapshot[:message], snapshot[:elapsed])
           end
-        Clacky::Logger.warn("[ph_debug] finish_unregister", oid: object_id, eid: @entry_id, final_frame: final_frame.to_s[0, 200])
+        Clacky::Logger.warn("[ph_debug] finish_unregister", oid: object_id, eid: @entry_id, first_close: snapshot[:first_close], final_frame: final_frame.to_s[0, 200])
         @owner.unregister_progress(self, final_frame: final_frame)
+        @monitor.synchronize { @unregistered = true }
         Clacky::Logger.warn("[ph_debug] finish_done", oid: object_id)
       end
       alias_method :cancel, :finish

data/lib/clacky/version.rb

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

data/lib/clacky/vision/resolver.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "digest"
+require "base64"
+require "fileutils"
+require "json"
+require_relative "../utils/file_processor"
+
+module Clacky
+  module Vision
+    # OCR sidecar — turns image bytes into a text description by calling a
+    # vision-capable model. Used when the user's primary model is text-only
+    # (e.g. DeepSeek V4) so that uploaded images and tool screenshots still
+    # reach the conversation as useful context.
+    #
+    # Routes through Clacky::Client so we get the same OpenAI/Anthropic/
+    # Bedrock format negotiation, retry, and credit-error handling as the
+    # main agent path. Image content travels as a canonical `image_url`
+    # block (the unified internal shape understood by all three formats).
+    class Resolver
+      DEFAULT_PROMPT = <<~PROMPT.strip
+        Extract every legible text and describe the visual content of this image.
+        Output as Markdown. Preserve table layout where possible (use Markdown tables).
+        For UI screenshots, describe the layout, visible labels, and active state.
+        Be thorough but concise — the user cannot see the image and must rely on
+        your description.
+      PROMPT
+
+      MAX_TOKENS = 8192
+      CACHE_DIR  = File.join(Dir.home, ".clacky", "ocr_cache")
+      CACHE_VERSION = 1
+
+      Result = Struct.new(:status, :text, :error, keyword_init: true) do
+        def ok?;          status == :ok;          end
+        def empty?;       status == :empty;       end
+        def call_failed?; status == :call_failed; end
+        def bad_image?;   status == :bad_image;   end
+      end
+
+      def initialize(model_entry)
+        @model_entry = model_entry
+        @model       = model_entry["model"]
+        @base_url    = model_entry["base_url"]
+        @api_key     = model_entry["api_key"]
+        @anthropic   = !!model_entry["anthropic_format"]
+      end
+
+      # @return [Result] one of:
+      #   status=:ok          + text   — sidecar produced a description
+      #   status=:empty               — sidecar returned 200 but no usable text (e.g. token budget exhausted by reasoning)
+      #   status=:call_failed + error — network/parse/auth error from the sidecar
+      #   status=:bad_image           — image bytes unreadable / empty
+      def describe(image, prompt: nil)
+        prompt = prompt.to_s.strip
+        prompt = DEFAULT_PROMPT if prompt.empty?
+
+        bytes, mime = read_image(image)
+        return Result.new(status: :bad_image) if bytes.nil? || bytes.empty?
+
+        cached = cache_get(bytes, prompt)
+        return Result.new(status: :ok, text: cached) if cached
+
+        text = call_vlm(bytes, mime, prompt)
+        return Result.new(status: :empty) if text.nil? || text.strip.empty?
+
+        cache_put(bytes, prompt, text)
+        Result.new(status: :ok, text: text)
+      rescue => e
+        Clacky::Logger.warn("[Vision::Resolver] failed: #{e.class}: #{e.message}") if defined?(Clacky::Logger)
+        Result.new(status: :call_failed, error: "#{e.class}: #{e.message}")
+      end
+
+      private def read_image(image)
+        if image[:bytes]
+          [image[:bytes], image[:mime_type] || "image/png"]
+        elsif image[:data_url] || image["data_url"]
+          url = image[:data_url] || image["data_url"]
+          m = url.match(/\Adata:([^;]+);base64,(.*)\z/m)
+          return [nil, nil] unless m
+          [Base64.decode64(m[2]), m[1]]
+        elsif image[:path] || image["path"]
+          path = image[:path] || image["path"]
+          return [nil, nil] unless File.exist?(path)
+          [File.binread(path), Utils::FileProcessor.detect_mime_type(path, nil) || "image/png"]
+        else
+          [nil, nil]
+        end
+      end
+
+      private def call_vlm(bytes, mime, prompt)
+        data_url = "data:#{mime};base64,#{Base64.strict_encode64(bytes)}"
+        message = {
+          role: "user",
+          content: [
+            { type: "text", text: prompt },
+            { type: "image_url", image_url: { url: data_url } }
+          ]
+        }
+
+        client = Clacky::Client.new(
+          @api_key,
+          base_url: @base_url,
+          model: @model,
+          anthropic_format: @anthropic
+        )
+        response = client.send_messages([message], model: @model, max_tokens: MAX_TOKENS)
+        extract_text(response)
+      end
+
+      # Client#send_messages returns the raw upstream string for OpenAI/Anthropic;
+      # for Bedrock it returns the parsed text content. Normalise to String.
+      private def extract_text(response)
+        case response
+        when String then response
+        when Hash   then response[:content] || response["content"] || response.to_s
+        else response.to_s
+        end
+      end
+
+      # ── Cache ─────────────────────────────────────────────────────────────
+
+      private def cache_key(bytes, prompt)
+        sha = Digest::SHA256.hexdigest(bytes)
+        prompt_sha = Digest::SHA256.hexdigest(prompt)[0, 12]
+        "#{sha}_#{@model.gsub(/[^A-Za-z0-9_.-]/, '_')}_#{prompt_sha}"
+      end
+
+      private def cache_path(key)
+        File.join(CACHE_DIR, "#{key}.json")
+      end
+
+      private def cache_get(bytes, prompt)
+        path = cache_path(cache_key(bytes, prompt))
+        return nil unless File.exist?(path)
+        data = JSON.parse(File.read(path))
+        return nil unless data["v"] == CACHE_VERSION
+        data["text"]
+      rescue JSON::ParserError, Errno::ENOENT
+        nil
+      end
+
+      private def cache_put(bytes, prompt, text)
+        FileUtils.mkdir_p(CACHE_DIR)
+        path = cache_path(cache_key(bytes, prompt))
+        File.write(path, JSON.generate({
+          "v"     => CACHE_VERSION,
+          "model" => @model,
+          "text"  => text,
+          "ts"    => Time.now.to_i
+        }))
+      rescue => _
+        # Cache is best-effort — never fail the request because we can't write.
+        nil
+      end
+    end
+  end
+end

data/lib/clacky/web/app.css

@@ -325,6 +325,13 @@ body {
 .theme-toggle-btn:active {
   background: var(--color-bg-hover);
 }
+/* Sound-notification toggle shares .theme-toggle-btn; highlight when ON. */
+#notify-toggle-header.notify-on {
+  color: var(--color-accent-primary, var(--color-text-primary));
+}
+#notify-toggle-header.notify-on:hover {
+  color: var(--color-accent-primary, var(--color-text-primary));
+}
 
 /* ── Content Row (Sidebar + Main) ───────────────────────────────────────── */
 #app > aside,
@@ -2282,19 +2289,31 @@ body {
 
 /* ── Diff block (rendered inline within edit/write tool-item) ─────────────── */
 .tool-item-diff {
-  margin: 0.25rem 0 0.25rem 1.25rem;
-  padding: 0.375rem 0.5rem;
+  margin: 0.375rem 0 0.375rem 1.25rem;
+  padding: 0.5rem 0.625rem;
   background: var(--color-bg-secondary);
   border: 1px solid var(--color-border-secondary);
-  border-radius: 4px;
+  border-radius: 6px;
   font-size: 0.6875rem;
   font-family: monospace;
-  line-height: 1.5;
+  line-height: 1.55;
   max-height: 20rem;
-  overflow: auto;
+  overflow-x: hidden;
+  overflow-y: auto;
+  scrollbar-width: thin;
+  scrollbar-color: var(--color-border-secondary) transparent;
 }
+.tool-item-diff::-webkit-scrollbar { width: 6px; height: 6px; }
+.tool-item-diff::-webkit-scrollbar-track { background: transparent; }
+.tool-item-diff::-webkit-scrollbar-thumb {
+  background: var(--color-border-secondary);
+  border-radius: 3px;
+}
+.tool-item-diff::-webkit-scrollbar-thumb:hover { background: var(--color-text-tertiary); }
 .diff-line {
-  white-space: pre;
+  white-space: pre-wrap;
+  word-break: break-all;
+  overflow-wrap: anywhere;
   padding: 0 0.25rem;
   border-radius: 2px;
 }
@@ -3559,6 +3578,37 @@ body {
 }
 .btn-settings-action:hover { background: var(--color-bg-hover); border-color: var(--color-accent-primary); }
 .btn-settings-action:disabled { opacity: 0.5; cursor: not-allowed; }
+
+.settings-network {
+  display: flex;
+  flex-direction: column;
+  gap: 0.875rem;
+  padding: 0.875rem 1rem;
+  background: var(--color-bg-secondary);
+  border: 1px solid var(--color-border-primary);
+  border-radius: 10px;
+}
+.settings-network-desc {
+  font-size: 0.8125rem;
+  color: var(--color-text-secondary);
+  line-height: 1.5;
+  margin: 0;
+}
+.settings-network-url {
+  display: flex;
+  flex-direction: column;
+  gap: 0.375rem;
+}
+.settings-network-url-label {
+  font-size: 0.75rem;
+  color: var(--color-text-secondary);
+}
+.settings-network-url-row {
+  display: flex;
+  gap: 0.5rem;
+  align-items: center;
+}
+.settings-network-url-row .field-input { flex: 1; }
 .settings-loading, .settings-empty, .settings-error {
   color: var(--color-text-secondary);
   font-size: 0.8125rem;

data/lib/clacky/web/i18n.js

@@ -505,12 +505,13 @@ const I18n = (() => {
       "settings.models.badge.default": "Default",
       "settings.models.badge.lite":    "Lite",
       "settings.media.title":         "Media Generation",
-      "settings.media.desc":          "Optional. Image / video / audio generation models.",
+      "settings.media.desc":          "Optional. Image / video / audio / OCR sidecar models.",
       "settings.media.loading":       "Loading…",
       "settings.media.error":         "Failed to load: {{msg}}",
       "settings.media.kind.image":    "Image",
       "settings.media.kind.video":    "Video",
       "settings.media.kind.audio":    "Audio",
+      "settings.media.kind.ocr":      "OCR",
       "settings.media.source.off":    "Off",
       "settings.media.source.auto":   "Auto",
       "settings.media.source.custom": "Custom",
@@ -597,6 +598,14 @@ const I18n = (() => {
       "settings.browser.btn":              "🌐 Configure Browser",
       "settings.browser.btn.reconfigure":  "🌐 Reconfigure Browser",
       "settings.browser.btn.starting":     "Starting…",
+      "settings.network.title":            "Network",
+      "settings.network.desc":             "Clacky always ignores HTTP_PROXY / HTTPS_PROXY from your shell. Set an explicit proxy URL below to route Clacky's outbound traffic through a proxy.",
+      "settings.network.proxyUrl":         "Proxy URL",
+      "settings.network.save":             "Save",
+      "settings.network.saved":            "Saved",
+      "settings.network.clear":            "Clear",
+      "settings.network.cleared":          "Cleared — direct connection",
+      "settings.network.invalidUrl":       "Invalid URL — use http://host:port or http://user:pass@host:port",
       "settings.brand.title":              "Brand & License",
       "settings.brand.label.brand":        "Brand",
       "settings.brand.label.status":       "Status",
@@ -697,6 +706,8 @@ const I18n = (() => {
       "brand.banner.freePromptBoth":      "Welcome to {{name}} — {{free}} free skill{{freePlural}} ready to use, plus {{paid}} premium skill{{paidPlural}} unlockable with a serial number.",
 
       "header.owner.tooltip":     "Creator — click to open Creator Hub",
+      "notify.tooltip.on":        "Sound on task complete: ON (click to mute)",
+      "notify.tooltip.off":       "Sound on task complete: OFF (click to enable)",
 
       // ── Session info bar / Model switcher benchmark ──
       "sib.bench.btn":        "Benchmark",
@@ -1245,12 +1256,13 @@ const I18n = (() => {
       "settings.models.badge.default": "默认",
       "settings.models.badge.lite":    "轻量",
       "settings.media.title":         "媒体生成",
-      "settings.media.desc":          "可选。图片 / 视频 / 音频 生成模型。",
+      "settings.media.desc":          "可选。图片 / 视频 / 音频 / 图片理解（OCR）副模型。",
       "settings.media.loading":       "加载中…",
       "settings.media.error":         "加载失败：{{msg}}",
       "settings.media.kind.image":    "图片",
       "settings.media.kind.video":    "视频",
       "settings.media.kind.audio":    "音频",
+      "settings.media.kind.ocr":      "OCR",
       "settings.media.source.off":    "关闭",
       "settings.media.source.auto":   "自动",
       "settings.media.source.custom": "自定义",
@@ -1337,6 +1349,14 @@ const I18n = (() => {
       "settings.browser.btn":              "🌐 配置浏览器",
       "settings.browser.btn.reconfigure":  "🌐 重新配置浏览器",
       "settings.browser.btn.starting":     "启动中…",
+      "settings.network.title":            "网络",
+      "settings.network.desc":             "Clacky 始终忽略系统的 HTTP_PROXY / HTTPS_PROXY。如需让 Clacky 走代理，请在下方填入显式代理地址。",
+      "settings.network.proxyUrl":         "代理地址",
+      "settings.network.save":             "保存",
+      "settings.network.saved":            "已保存",
+      "settings.network.clear":            "清除",
+      "settings.network.cleared":          "已清除 — 直连",
+      "settings.network.invalidUrl":       "地址格式不正确，请使用 http://host:port 或 http://user:pass@host:port",
       "settings.brand.title":              "品牌 & 授权",
       "settings.brand.label.brand":        "品牌",
       "settings.brand.label.status":       "状态",
@@ -1437,6 +1457,8 @@ const I18n = (() => {
       "brand.banner.freePromptBoth":      "欢迎使用 {{name}} — 已自动安装 {{free}} 个免费技能，还有 {{paid}} 个增值技能可输入序列号解锁。",
 
       "header.owner.tooltip":     "创作者 — 点击进入创作者中心",
+      "notify.tooltip.on":        "任务完成提示音：已开启（点击关闭）",
+      "notify.tooltip.off":       "任务完成提示音：已关闭（点击开启）",
 
       // ── 会话信息栏 / 模型切换器 测速 ──
       "sib.bench.btn":        "测速",