openclacky 1.4.0 → 1.5.0

data/lib/clacky/platform_http_client.rb

@@ -24,17 +24,19 @@ module Clacky
   #   # result => { success: true, data: {...} }
   #   #        or { success: false, error: "...", data: {} }
   class PlatformHttpClient
-    # Primary CDN-accelerated endpoint
-    PRIMARY_HOST  = "https://www.openclacky.com"
+    # Primary endpoint
+    PRIMARY_HOST   = "https://www.openclacky.com"
+    # Secondary CDN-accelerated endpoint (China mainland)
+    SECONDARY_HOST = "https://api.1024code.com"
     # Direct fallback — bypasses EdgeOne, used when the primary times out
-    FALLBACK_HOST = "https://openclacky.up.railway.app"
+    FALLBACK_HOST  = "https://openclacky.up.railway.app"
 
     # Number of attempts per domain (1 = no retry within the same domain)
-    ATTEMPTS_PER_HOST = 2
+    ATTEMPTS_PER_HOST = 1
     # Initial back-off between retries within the same domain (seconds)
     INITIAL_BACKOFF   = 0.5
     # Connection / read timeouts (seconds) for API calls
-    OPEN_TIMEOUT  = 8
+    OPEN_TIMEOUT  = 5
     READ_TIMEOUT  = 15
     # Read timeout for streaming large file downloads (seconds)
     DOWNLOAD_READ_TIMEOUT = 120
@@ -53,12 +55,12 @@ module Clacky
 
     # Auto-detects the target host(s):
     #   - When CLACKY_LICENSE_SERVER is set → single host (dev override, no failover)
-    #   - Otherwise                   → [PRIMARY_HOST, FALLBACK_HOST]
+    #   - Otherwise                   → [PRIMARY_HOST, SECONDARY_HOST, FALLBACK_HOST]
     def initialize
       if (override = ENV["CLACKY_LICENSE_SERVER"]) && !override.empty?
         @hosts = [override]
       else
-        @hosts = [PRIMARY_HOST, FALLBACK_HOST]
+        @hosts = [PRIMARY_HOST, SECONDARY_HOST, FALLBACK_HOST]
       end
     end
 

data/lib/clacky/providers.rb

@@ -260,8 +260,8 @@ module Clacky
         "name" => "Kimi (Moonshot)",
         "base_url" => "https://api.moonshot.cn/v1",
         "api" => "openai-completions",
-        "default_model" => "kimi-k2.6",
-        "models" => ["kimi-k2.6", "kimi-k2.5"],
+        "default_model" => "kimi-k3",
+        "models" => ["kimi-k3", "kimi-k2.7-code", "kimi-k2.7-code-highspeed", "kimi-k2.6", "kimi-k2.5"],
         # Moonshot operates two regional endpoints with identical APIs & model
         # lineup — mainland China (.cn) and international (.ai). These are the
         # pay-as-you-go Open Platform endpoints; the subscription-billed
@@ -277,9 +277,9 @@ module Clacky
           { "label" => "Mainland China", "label_key" => "settings.models.baseurl.variant.mainland_cn",   "base_url" => "https://api.moonshot.cn/v1", "region" => "cn"   }.freeze,
           { "label" => "International",  "label_key" => "settings.models.baseurl.variant.international", "base_url" => "https://api.moonshot.ai/v1", "region" => "intl" }.freeze
         ].freeze,
-        # k2.5 / k2.6 are multimodal; legacy k2 text-only models need model_capabilities override if added.
+        # k3 / k2.7-code / k2.5 / k2.6 are multimodal; legacy k2 text-only models need model_capabilities override if added.
         "capabilities" => { "vision" => true }.freeze,
-        "default_ocr_model" => "kimi-k2.5",
+        "default_ocr_model" => "kimi-k3",
         "website_url" => "https://platform.moonshot.cn/console/api-keys"
       }.freeze,
 
@@ -376,6 +376,70 @@ module Clacky
         "website_url" => "https://open.bigmodel.cn/usercenter/apikeys"
       }.freeze,
 
+      # Volcengine Ark (Doubao) — ByteDance's model platform, OpenAI-compatible.
+      # Exposes three functionally-equivalent endpoints (Pay-as-you-go / Coding
+      # Plan / Agent Plan) that share the same model lineup and capability
+      # profile, so a single preset with endpoint_variants is the right shape.
+      # Without a preset match, base_urls like /api/coding/v3 fell through to the
+      # conservative "assume vision=true" default and inlined images into
+      # text-only models (e.g. glm-5.2), which Ark rejects. The vision matrix
+      # below is the source of truth so text-only models route through the OCR
+      # sidecar instead.
+      "volcengine-ark" => {
+        "name" => "Volcengine Ark (Doubao)",
+        "name_key" => "provider.name.volcengine_ark",
+        "base_url" => "https://ark.cn-beijing.volces.com/api/v3",
+        "api" => "openai-completions",
+        "default_model" => "doubao-seed-2.0-pro",
+        "models" => [
+          "doubao-seed-evolving",
+          "doubao-seed-2.1-pro",
+          "doubao-seed-2.1-turbo",
+          "doubao-seed-2.0-code",
+          "doubao-seed-2.0-pro",
+          "doubao-seed-2.0-lite",
+          "minimax-m3",
+          "minimax-m2.7",
+          "kimi-k2.7-code",
+          "kimi-k2.6",
+          "glm-5.2",
+          "deepseek-v4-pro",
+          "deepseek-v4-flash"
+        ],
+        "endpoint_variants" => [
+          { "label" => "Pay-as-you-go", "label_key" => "settings.models.baseurl.variant.ark_payg",   "base_url" => "https://ark.cn-beijing.volces.com/api/v3", "alias_group" => "payg" }.freeze,
+          { "label" => "Coding Plan",   "label_key" => "settings.models.baseurl.variant.ark_coding", "base_url" => "https://ark.cn-beijing.volces.com/api/coding/v3" }.freeze,
+          { "label" => "Agent Plan",    "label_key" => "settings.models.baseurl.variant.ark_agent",  "base_url" => "https://ark.cn-beijing.volces.com/api/plan/v3" }.freeze
+        ].freeze,
+        # Pay-as-you-go billing endpoint requires versioned model ids, while the
+        # Coding/Agent Plan endpoints accept the short display names. Users pick
+        # the intuitive short name; on the payg endpoint we transparently swap
+        # it for the versioned id the billing API expects. Only models whose ids
+        # actually differ are listed here.
+        "api_model_aliases" => {
+          "payg" => {
+            "glm-5.2"            => "glm-5-2-260617",
+            "deepseek-v4-pro"    => "deepseek-v4-pro-260425",
+            "deepseek-v4-flash"  => "deepseek-v4-flash-260425",
+            "doubao-seed-2.1-pro"   => "doubao-seed-2-1-pro-260628",
+            "doubao-seed-2.1-turbo" => "doubao-seed-2-1-turbo-260628",
+            "doubao-seed-2.0-pro"   => "doubao-seed-2-0-pro-260215",
+            "doubao-seed-2.0-lite"  => "doubao-seed-2-0-lite-260428",
+            "doubao-seed-2.0-code"  => "doubao-seed-2-0-code-preview-260215"
+          }.freeze
+        }.freeze,
+        # Most Doubao/multimodal models accept image input; GLM-5.2 and
+        # DeepSeek-V4 on Ark are text-only.
+        "capabilities" => { "vision" => true }.freeze,
+        "model_capabilities" => {
+          "glm-5.2"           => { "vision" => false }.freeze,
+          "deepseek-v4-pro"   => { "vision" => false }.freeze,
+          "deepseek-v4-flash" => { "vision" => false }.freeze
+        }.freeze,
+        "default_ocr_model" => "doubao-seed-2.0-lite",
+        "website_url" => "https://console.volcengine.com/ark/region:cn-beijing/overview"
+      }.freeze,
+
       "openai" => {
         "name" => "OpenAI (GPT)",
         "base_url" => "https://api.openai.com/v1",
@@ -788,7 +852,51 @@ module Clacky
         nil
       end
 
-      # Resolve the capabilities hash for a given provider+model.
+      # Translate a display model name into the real model id the target
+      # endpoint expects. Some providers expose the same model under different
+      # ids per billing endpoint (e.g. Volcengine Ark's pay-as-you-go API needs
+      # versioned ids like "doubao-seed-2-0-pro-260215" while the Coding/Agent
+      # Plan endpoints accept the short "doubao-seed-2.0-pro"). Users always see
+      # and pick the short name; this swaps it just before the request goes out.
+      #
+      # Returns the original model unchanged when no alias applies (unknown
+      # provider, endpoint without an alias group, or model not in the map).
+      #
+      # @param base_url [String, nil] the configured base_url (identifies endpoint)
+      # @param api_key  [String, nil] the configured api_key (provider fallback)
+      # @param model    [String, nil] the display model name
+      # @return [String, nil] the real model id to send, or the input unchanged
+      def resolve_api_model(base_url:, api_key: nil, model:)
+        return model if model.nil?
+
+        provider_id = resolve_provider(base_url: base_url, api_key: api_key)
+        return model unless provider_id
+
+        preset = PRESETS[provider_id]
+        aliases = preset && preset["api_model_aliases"]
+        return model unless aliases.is_a?(Hash)
+
+        group = alias_group_for_base_url(preset, base_url)
+        return model unless group
+
+        aliases.dig(group, model.to_s) || model
+      end
+
+      # Find which alias group the given base_url belongs to by matching it
+      # against the preset's endpoint_variants. Uses exact base_url equality
+      # (after normalising trailing slash) so "/api/v3" never leaks into the
+      # "/api/coding/v3" match.
+      def alias_group_for_base_url(preset, base_url)
+        return nil if base_url.nil?
+        variants = preset["endpoint_variants"]
+        return nil unless variants.is_a?(Array)
+
+        normalized = base_url.to_s.chomp("/")
+        variant = variants.find do |v|
+          v.is_a?(Hash) && v["base_url"].to_s.chomp("/") == normalized
+        end
+        variant && variant["alias_group"]
+      end
       #
       # Resolution order (most specific wins):
       #   1. PRESETS[provider_id]["model_capabilities"][model_name] — per-model

data/lib/clacky/server/http_server.rb

@@ -36,9 +36,10 @@ module Clacky
         @events     = events
       end
 
-      def show_user_message(content, created_at: nil, files: [])
+      def show_user_message(content, created_at: nil, files: [], editable: true)
         ev = { type: "history_user_message", session_id: @session_id, content: content }
         ev[:created_at] = created_at if created_at
+        ev[:editable] = false unless editable
         rendered = Array(files).filter_map do |f|
           url  = f[:data_url] || f["data_url"]
           name = f[:name]     || f["name"]
@@ -545,6 +546,7 @@ module Clacky
         when ["POST",   "/api/onboard/skip-soul"] then api_onboard_skip_soul(req, res)
         when ["GET",    "/api/store/skills"]          then api_store_skills(res)
         when ["GET",    "/api/store/extensions"]          then api_store_extensions(req, res)
+        when ["GET",    "/api/store/extensions/brand"]   then api_store_extensions_brand(res)
         when ["GET",    "/api/store/extensions/installed"] then api_store_extensions_installed(res)
         when ["GET",    "/api/store/extension"]       then api_store_extension_detail(req, res)
         when ["POST",   "/api/store/extension/install"]  then api_store_extension_install(req, res)
@@ -964,11 +966,13 @@ module Clacky
       # Phase "key_setup"  → no API key configured yet
       # Phase "soul_setup" → key configured, but ~/.clacky/agents/SOUL.md missing
       # needs_onboard: false → fully set up
+      # branded: true → running under a brand; hide the OpenClacky AI Keys block
       def api_onboard_status(res)
+        branded = Clacky::BrandConfig.load.branded?
         if !@agent_config.models_configured?
-          json_response(res, 200, { needs_onboard: true, phase: "key_setup" })
+          json_response(res, 200, { needs_onboard: true, phase: "key_setup", branded: branded })
         else
-          json_response(res, 200, { needs_onboard: false })
+          json_response(res, 200, { needs_onboard: false, branded: branded })
         end
       end
 
@@ -2309,6 +2313,9 @@ module Clacky
           # Refresh skill_loader with the now-activated brand config so brand
           # skills are loadable from this point forward (e.g. after sync).
           @skill_loader = Clacky::SkillLoader.new(working_dir: nil, brand_config: brand)
+          # Install all brand skills in the background on first activation so
+          # they are available immediately without manual user action.
+          brand.sync_brand_skills_async!(install_new: true)
           json_response(res, 200, {
             ok:            true,
             product_name:  result[:product_name] || brand.product_name,
@@ -2359,10 +2366,9 @@ module Clacky
 
       # GET /api/store/extensions?q=&sort=
       #
-      # Public extension marketplace catalog. Anonymous (no license needed).
-      # Proxies BrandConfig#search_extensions! which hits the platform's public
-      # /api/v1/extensions endpoint. Extension archives are NOT downloadable here
-      # — they ship inside license-gated brand packages (path B distribution).
+      # Public extension marketplace catalog — always returns the full public
+      # catalog regardless of brand status. Both brand and non-brand users see
+      # the same public marketplace here.
       def api_store_extensions(req, res)
         brand  = Clacky::BrandConfig.load
         result = brand.search_extensions!(query: req.query["q"], sort: req.query["sort"])
@@ -2370,7 +2376,7 @@ module Clacky
         if result[:success]
           installed = installed_extension_containers
           extensions = Array(result[:extensions]).map do |ext|
-            slug = ext["name"] || ext[:name] || ext["slug"] || ext[:slug]
+            slug      = ext["name"] || ext[:name] || ext["slug"] || ext[:slug]
             container = installed[slug]
             ext.merge(
               "installed"         => !container.nil?,
@@ -2387,6 +2393,49 @@ module Clacky
         end
       end
 
+      # GET /api/store/extensions/brand
+      #
+      # Brand-private extension catalog — only available to users with an
+      # activated brand license. Returns extensions belonging to this brand via
+      # BrandConfig#fetch_brand_extensions!.
+      # Returns 403 when the license is not activated.
+      def api_store_extensions_brand(res)
+        brand = Clacky::BrandConfig.load
+
+        unless brand.activated?
+          json_response(res, 403, { ok: false, error: "Brand license not activated." })
+          return
+        end
+
+        result = brand.fetch_brand_extensions!
+
+        if result[:success]
+          installed = installed_extension_containers
+          extensions = Array(result[:extensions]).map do |ext|
+            slug      = ext["name"] || ext[:name] || ext["slug"] || ext[:slug]
+            container = installed[slug]
+            # Merge local container data (e.g. emoji) for self-authored extensions.
+            local_overrides = {}
+            if container && ext["emoji"].to_s.empty?
+              local_emoji = container.dig(:raw, "emoji") || container[:emoji]
+              local_overrides["emoji"] = local_emoji if local_emoji.to_s.strip != ""
+            end
+            ext.merge(
+              "installed"         => !ext["installed_version"].nil?,
+              "installed_version" => ext["installed_version"],
+              **local_overrides
+            )
+          end
+          json_response(res, 200, { ok: true, extensions: extensions })
+        else
+          json_response(res, 200, {
+            ok:         true,
+            extensions: [],
+            warning:    result[:error] || "Could not reach the extension store."
+          })
+        end
+      end
+
       # GET /api/store/extensions/installed
       #
       # Returns all locally installed extensions (all layers: builtin, installed,
@@ -2405,23 +2454,35 @@ module Clacky
 
         extensions = local_entries.map do |ext_id, container|
           market = market_by_slug[ext_id]
+          # For self-authored (origin: self) extensions market is nil.
+          # Fall back to local ext.yml data so name/description/author are populated.
+          local_name   = container[:name].to_s.then { |n| n.empty? ? ext_id : n }
+          local_desc   = container.dig(:raw, "description").to_s
+          local_author = container[:author].to_s
+          local_units  = units_from_container(container)
           {
             "id"                => ext_id,
-            "name"              => market ? (market["name"] || ext_id) : ext_id,
+            "name"              => market ? (market["name"] || ext_id) : local_name,
+            "display_name"      => market&.dig("display_name"),
+            "display_name_zh"   => market&.dig("display_name_zh"),
             "name_zh"           => market&.dig("name_zh"),
             "name_en"           => market&.dig("name_en"),
             "slug"              => ext_id,
             "version"           => market ? (market["version"] || container[:version]) : container[:version],
             "installed_version" => container[:version],
-            "description"       => market&.dig("description"),
-            "author"            => market&.dig("author"),
+            "description"       => market ? market["description"] : local_desc,
+            "author"            => market ? market["author"] : local_author,
             "icon_url"          => market&.dig("icon_url"),
-            "units"             => market&.dig("units"),
-            "homepage"          => market ? (market["homepage"] || "") : "",
+            "units"             => market ? market["units"] : local_units,
+            "homepage"          => market ? (market["homepage"] || "") : container[:homepage].to_s,
             "origin"            => market ? (market["origin"] || container[:origin]) : container[:origin],
             "hub_active"        => market&.dig("hub_active"),
             "download_count"    => market&.dig("download_count").to_i,
-            "unlisted"          => market.nil?,
+            # Only mark as unlisted when the extension was published to the
+            # marketplace (origin != "self") but is no longer listed there.
+            # Self-authored extensions (origin: self) have never been published
+            # and should never show the "unlisted" badge.
+            "unlisted"          => market.nil? && container[:origin].to_s != "self",
             "layer"             => container[:layer].to_s,
             "installed"         => true,
             "removable"         => true,
@@ -2465,6 +2526,21 @@ module Clacky
         {}
       end
 
+      # Build a units summary hash from local ext.yml contributes data,
+      # mirroring the format platform's unit_summary returns: { "api" => n, ... }
+      private def units_from_container(container)
+        contributes = container[:contributes] || {}
+        units = {}
+        units["api"]   = 1 unless (contributes["api"] || contributes[:api]).to_s.empty?
+        panels = Array(contributes["panels"] || contributes[:panels])
+        units["panel"] = panels.size if panels.any?
+        agents = Array(contributes["agents"] || contributes[:agents])
+        units["agent"] = agents.size if agents.any?
+        skills = Array(contributes["skills"] || contributes[:skills])
+        units["skill"] = skills.size if skills.any?
+        units
+      end
+
       # GET /api/store/extension?id=<slug-or-id>
       #
       # Public detail for a single marketplace extension (contributes + version
@@ -2477,7 +2553,10 @@ module Clacky
         end
 
         brand  = Clacky::BrandConfig.load
-        result = brand.extension_detail!(id)
+        # Brand-private extensions (origin=self) are not visible via the public
+        # /api/v1/extensions/:id endpoint. Activated brand users must use the
+        # license-gated POST /api/v1/licenses/extension instead.
+        result = brand.activated? ? brand.brand_extension_detail!(id) : brand.extension_detail!(id)
 
         if result[:success] && result[:extension]
           ext  = result[:extension]
@@ -2494,22 +2573,29 @@ module Clacky
           container = extension_container(id)
           if container && container[:layer] == :installed
             market = fetch_batch_market_data([id])[id]
+            # Fall back to local ext.yml for self-authored extensions.
+            local_name   = container[:name].to_s.then { |n| n.empty? ? id : n }
+            local_desc   = container.dig(:raw, "description").to_s
+            local_author = container[:author].to_s
+            local_units  = units_from_container(container)
             ext = {
               "id"                => id,
-              "name"              => market ? (market["name"] || id) : id,
+              "name"              => market ? (market["name"] || id) : local_name,
               "name_zh"           => market&.dig("name_zh"),
               "name_en"           => market&.dig("name_en"),
               "slug"              => id,
               "version"           => market ? (market["version"] || container[:version]) : container[:version],
               "installed_version" => container[:version],
-              "description"       => market&.dig("description"),
-              "author"            => market&.dig("author"),
+              "description"       => market ? market["description"] : local_desc,
+              "author"            => market ? market["author"] : local_author,
               "icon_url"          => market&.dig("icon_url"),
-              "units"             => market&.dig("units"),
-              "homepage"          => market ? (market["homepage"] || "") : "",
+              "units"             => market ? market["units"] : local_units,
+              "homepage"          => market ? (market["homepage"] || "") : container[:homepage].to_s,
               "origin"            => market ? (market["origin"] || container[:origin]) : container[:origin],
               "hub_active"        => market&.dig("hub_active"),
-              "unlisted"          => market.nil?,
+              # Only mark as unlisted when the extension was published to the
+              # marketplace (origin != "self") but is no longer listed there.
+              "unlisted"          => market.nil? && container[:origin].to_s != "self",
               "installed"         => true,
               "removable"         => true,
               "disabled"          => container[:disabled] == true,
@@ -2577,7 +2663,9 @@ module Clacky
       end
 
       def api_store_extension_uninstall(req, res)
-        id = parse_json_body(req)["id"].to_s
+        body = parse_json_body(req)
+        id = body["id"].to_s
+        purge_data = body["purge_data"] == true
         container = extension_container(id)
         if container.nil?
           json_response(res, 404, { ok: false, error: "Not installed." })
@@ -2588,7 +2676,7 @@ module Clacky
           return
         end
 
-        if Clacky::ExtensionLoader.uninstall!(id)
+        if Clacky::ExtensionLoader.uninstall!(id, purge_data: purge_data)
           json_response(res, 200, { ok: true, id: id })
         else
           json_response(res, 404, { ok: false, error: "Not installed." })
@@ -3691,13 +3779,11 @@ module Clacky
 
         return json_response(res, 400, { error: "path is required" }) unless path && !path.empty?
 
-        # Expand ~ to the user's home directory (e.g. "~/Desktop/file.pdf").
-        # Ruby's File.exist? does NOT automatically expand ~ — that's a shell feature.
-        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 arrives already percent-decoded by the click handler; normalize
+        # Windows drive letters (WSL) BEFORE expand_path or the drive is treated
+        # as relative and corrupted. No-op on macOS/Linux.
         linux_path = Utils::EnvironmentDetector.win_to_linux_path(path)
+        linux_path = File.expand_path(linux_path)
 
         return json_response(res, 404, { error: "file not found" }) unless File.exist?(linux_path)
 
@@ -3711,8 +3797,11 @@ module Clacky
           json_response(res, 200, { ok: true })
         when "download"
           serve_file_download(res, linux_path)
+        when "display-path"
+          display = Utils::EnvironmentDetector.linux_to_win_path(linux_path)
+          json_response(res, 200, { ok: true, path: display })
         else
-          json_response(res, 400, { error: "invalid action. Must be 'open', 'reveal' or 'download'" })
+          json_response(res, 400, { error: "invalid action. Must be 'open', 'reveal', 'download' or 'display-path'" })
         end
       rescue => e
         json_response(res, 500, { ok: false, error: e.message })
@@ -3742,14 +3831,9 @@ module Clacky
         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)
+        # Strip file://, decode, WSL drive-letter normalize, then expand — in
+        # this order (normalize must precede expand_path). No-op on macOS/Linux.
+        path = Utils::EnvironmentDetector.resolve_local_path(raw_path)
 
         # Security: only serve media files (images + videos)
         ext = File.extname(path).downcase
@@ -5724,6 +5808,9 @@ module Clacky
           {
             id:                id,
             name:              preset["name"],
+            # Optional i18n key for the display name (localised per UI language);
+            # frontend falls back to `name` when absent or untranslated.
+            name_key:          preset["name_key"],
             base_url:          preset["base_url"],
             default_model:     preset["default_model"],
             models:            preset["models"] || [],
@@ -6423,6 +6510,12 @@ module Clacky
       private def interrupt_all_agents
         return unless @registry && @session_manager
 
+        # Stop idle compression first: an in-flight compression must fully roll
+        # back (or complete) before the worker is killed, otherwise a hot
+        # restart's SIGKILL can leave a chunk file on disk whose chunk_path
+        # never made it into session.json (history vanishes on replay).
+        @registry.shutdown_all_idle_timers
+
         @registry.each_live_agent do |id, agent, thread|
           next unless thread&.alive?
           begin

data/lib/clacky/server/session_registry.rb

@@ -496,6 +496,15 @@ module Clacky
         snapshot.each { |id, agent, thread| yield id, agent, thread }
       end
 
+      # Shut down every session's idle-compression timer, waiting for any
+      # in-flight compression to roll back cleanly. Called on worker shutdown
+      # so a hot restart's SIGKILL cannot tear a compression apart between
+      # writing the chunk file and persisting its chunk_path into session.json.
+      def shutdown_all_idle_timers
+        timers = @mutex.synchronize { @sessions.values.filter_map { |s| s[:idle_timer] } }
+        timers.each { |t| t.shutdown rescue nil }
+      end
+
       private def persist_and_release(id, session)
         agent = session[:agent]
         @session_manager&.save(agent.to_session_data(status: :success, preserve_updated_at: true)) if agent

data/lib/clacky/tools/grep.rb

@@ -121,12 +121,17 @@ module Clacky
           files = if File.file?(expanded_path)
                     [expanded_path]
                   else
+                    # Auto-expand bare extension patterns (e.g. "*.ts") to recursive
+                    # (e.g. "**/*.ts"), matching ripgrep's default behaviour.
+                    # Patterns already containing "/" are left as-is — the user is
+                    # intentionally scoping to a specific directory.
+                    effective_pattern = file_pattern.include?("/") ? file_pattern : "**/#{file_pattern}"
                     fnmatch_flags = File::FNM_PATHNAME | File::FNM_DOTMATCH
                     collected = []
                     walk_status = {}
                     Clacky::Utils::FileIgnoreHelper.walk_files(expanded_path, skipped: skipped, status: walk_status) do |f|
                       relative = f[(expanded_path.length + 1)..]
-                      collected << f if File.fnmatch(file_pattern, relative, fnmatch_flags)
+                      collected << f if File.fnmatch(effective_pattern, relative, fnmatch_flags)
                     end
                     if walk_status[:truncated]
                       truncation_reason ||= "walk #{walk_status[:truncation_reason]}"

data/lib/clacky/utils/environment_detector.rb

@@ -52,17 +52,24 @@ module Clacky
         end
       end
 
-      # Convert a Windows-style path to a WSL/Linux-side path.
-      # e.g. "C:/Users/foo/file.txt" → "/mnt/c/Users/foo/file.txt"
-      # Returns the original path unchanged on non-WSL or if already a Linux path.
-      # @param path [String]
-      # @return [String]
+      # Convert a Windows-style path (incl. the "/C:/" three-slash-URL form) to
+      # a WSL /mnt path. No-op on non-WSL or non-drive-letter paths.
       def self.win_to_linux_path(path)
-        return path unless os_type == :wsl && path.match?(/\A[A-Za-z]:[\/\\]/)
+        return path unless os_type == :wsl
+
+        m = path.match(%r{\A/?([A-Za-z]):[/\\](.*)}m)
+        return path unless m
+
+        "/mnt/#{m[1].downcase}/#{m[2].gsub("\\", "/")}"
+      end
 
-        drive = path[0].downcase
-        rest  = path[2..].gsub("\\", "/")
-        "/mnt/#{drive}#{rest}"
+      # Resolve a "file://" URL or bare path into a real local path:
+      # strip "file://", percent-decode, WSL drive-letter normalize, then expand.
+      def self.resolve_local_path(href)
+        path = href.to_s.sub(%r{\Afile://}, "")
+        path = CGI.unescape(path)
+        path = win_to_linux_path(path)
+        File.expand_path(path)
       end
 
       # Convert a Linux-side path to a Windows-style path via wslpath.