openclacky 1.2.12 → 1.2.13

data/lib/clacky/session_manager.rb

@@ -3,6 +3,7 @@
 require "json"
 require "fileutils"
 require "securerandom"
+require "open3"
 
 module Clacky
   class SessionManager
@@ -51,6 +52,27 @@ module Clacky
       all_sessions.find { |s| s[:session_id].to_s.start_with?(session_id.to_s) }
     end
 
+    # Fork a session: create a copy with new id, "(copy)" name suffix, and reset stats.
+    # Returns the forked session data hash, or nil if the original is not found.
+    def fork(session_id)
+      original = load(session_id)
+      return nil unless original
+
+      forked = original.dup
+      forked[:session_id]  = self.class.generate_id
+      forked[:created_at]  = Time.now.iso8601
+      forked[:updated_at]  = Time.now.iso8601
+      forked[:pinned]      = false
+      forked[:name]        = "#{original[:name] || "Unnamed session"} (copy)"
+      forked[:stats] = (original[:stats] || {}).merge(
+        total_tasks: 0, total_iterations: 0, total_cost_usd: 0.0,
+        last_status: nil, last_error: nil
+      )
+
+      save(forked)
+      forked
+    end
+
     # Soft-delete: move session JSON + chunks to the session trash directory.
     # Returns true if found and moved, false if not found.
     def delete(session_id)
@@ -158,6 +180,104 @@ module Clacky
       limit ? sessions.first(limit) : sessions
     end
 
+    # Full-text grep over session JSON + chunk MD files.
+    # Case-sensitive: BSD grep -i is ~30x slower; Chinese has no case.
+    # Returns Hash<short_id String => snippet String> (snippet around the first match).
+    def search_content(query, timeout: 5)
+      q = query.to_s
+      return {} if q.strip.length < 2
+
+      files = Dir.glob(File.join(@sessions_dir, "*.json")) +
+              Dir.glob(File.join(@sessions_dir, "*-chunk-*.md"))
+      return {} if files.empty?
+
+      result = {}
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+      each_grep_batch(files) do |batch|
+        remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        break if remaining <= 0
+        out = run_with_timeout({ "LC_ALL" => "C" },
+                               "grep", "-H", "-F", "-m", "1", "--",
+                               q, *batch,
+                               timeout: remaining)
+        next unless out
+        out.each_line do |line|
+          path, _, rest = line.chomp.partition(":")
+          next if path.empty? || rest.empty?
+          sid = extract_short_id(File.basename(path))
+          next unless sid
+          next if result.key?(sid)
+          result[sid] = build_snippet(rest, q)
+        end
+      end
+      result
+    end
+
+    # Yield file batches whose joined argv length stays well under ARG_MAX.
+    # macOS ARG_MAX is ~256 KiB; we cap at 96 KiB to leave room for env.
+    private def each_grep_batch(files, max_bytes: 96 * 1024)
+      batch = []
+      size  = 0
+      files.each do |f|
+        len = f.bytesize + 1
+        if size + len > max_bytes && !batch.empty?
+          yield batch
+          batch = []
+          size  = 0
+        end
+        batch << f
+        size  += len
+      end
+      yield batch unless batch.empty?
+    end
+
+    private def build_snippet(line, query, radius: 80)
+      bytes = line.b
+      q = query.b
+      idx = bytes.index(q)
+      if idx.nil?
+        head = bytes.byteslice(0, radius * 2).to_s
+        return head.force_encoding("UTF-8").scrub("?").gsub(/\s+/, " ").strip
+      end
+
+      start_byte = [idx - radius, 0].max
+      stop_byte  = [idx + q.bytesize + radius, bytes.bytesize].min
+      snippet = bytes.byteslice(start_byte, stop_byte - start_byte).to_s
+      snippet = snippet.force_encoding("UTF-8").scrub("?")
+      snippet = "…" + snippet if start_byte > 0
+      snippet = snippet + "…" if stop_byte < bytes.bytesize
+      snippet.gsub(/\s+/, " ").strip
+    end
+
+    private def run_with_timeout(env, *cmd, timeout:)
+      Open3.popen3(env, *cmd) do |stdin, stdout, stderr, wait_thr|
+        stdin.close
+        out = +""
+        reader = Thread.new { out << stdout.read }
+        drain  = Thread.new { stderr.read }
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+        loop do
+          remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          break if remaining <= 0
+          break if wait_thr.join(remaining)
+        end
+        if wait_thr.alive?
+          Process.kill("TERM", wait_thr.pid) rescue nil
+          wait_thr.join(0.5)
+          Process.kill("KILL", wait_thr.pid) rescue nil if wait_thr.alive?
+          reader.kill; drain.kill
+          return nil
+        end
+        reader.join; drain.join
+        out
+      end
+    end
+
+    private def extract_short_id(basename)
+      m = basename.match(/-([0-9a-f]{8})(?:-chunk-\d+)?\.(?:json|md)\z/)
+      m && m[1]
+    end
+
     # Return the most recent session for a given working directory, or nil.
     def latest_for_directory(working_dir)
       all_sessions(current_dir: working_dir).first

data/lib/clacky/tools/web_search.rb

@@ -120,17 +120,67 @@ module Clacky
 
       # ── Bing ───────────────────────────────────────────────────────────────
 
+      BING_ENDPOINTS = [
+        ["cn.bing.com", "zh-CN,zh;q=0.9,en;q=0.8"],
+        ["www.bing.com", "en-US,en;q=0.9"]
+      ].freeze
+
+      # Race both Bing endpoints in parallel and return the first relevant result.
+      # cn.bing.com works best from mainland China; www.bing.com works best from
+      # overseas. Racing avoids guessing the network egress and recovers from
+      # one endpoint temporarily returning anti-scrape filler. If both return
+      # irrelevant garbage, fall back to whichever came back non-empty.
       private def search_bing(query, max_results)
-        encoded_query = CGI.escape(query)
-        # cn.bing.com redirects to www.bing.com for non-China IPs (e.g. GitHub CI);
-        # follow_redirects ensures both environments work with the same code path.
-        url = URI("https://cn.bing.com/search?q=#{encoded_query}&count=#{max_results}")
-        response = http_get(url, accept_language: "zh-CN,zh;q=0.9,en;q=0.8", follow_redirects: 2)
+        queue = Queue.new
+        threads = BING_ENDPOINTS.map do |host, lang|
+          Thread.new do
+            results = bing_fetch(host, lang, query, max_results)
+            queue.push([host, results])
+          rescue StandardError
+            queue.push([host, []])
+          end
+        end
+
+        winner = nil
+        runner_up = nil
+        BING_ENDPOINTS.length.times do
+          _host, results = queue.pop
+          if bing_results_relevant?(results, query)
+            winner = results
+            break
+          elsif !results.empty? && runner_up.nil?
+            runner_up = results
+          end
+        end
+
+        threads.each(&:kill)
+        winner || runner_up || []
+      end
+
+      private def bing_fetch(host, lang, query, max_results)
+        url = URI("https://#{host}/search?q=#{CGI.escape(query)}&count=#{max_results}&form=QBLH")
+        response = http_get(url, accept_language: lang, follow_redirects: 2,
+                                 referer: "https://#{host}/")
         return [] unless response.is_a?(Net::HTTPSuccess)
 
         parse_bing_html(response.body, max_results)
       end
 
+      # A real Bing answer mentions at least one query token in the titles or
+      # snippets. The anti-scrape fallback returns top-domain filler (Yandex,
+      # Bunnings, WikiLeaks, …) that shares nothing with the query.
+      private def bing_results_relevant?(results, query)
+        return false if results.empty?
+
+        tokens = query.downcase.scan(/[\p{L}\p{N}]+/).reject { |t| t.length < 2 }
+        return true if tokens.empty?
+
+        results.any? do |r|
+          haystack = "#{r[:title]} #{r[:snippet]}".downcase
+          tokens.any? { |t| haystack.include?(t) }
+        end
+      end
+
       private def parse_bing_html(html, max_results)
         results = []
         html = Clacky::Utils::Encoding.to_utf8(html)
@@ -199,7 +249,7 @@ module Clacky
 
       # Shared browser-like GET request — no Accept-Encoding to avoid gzip/br
       # detection tricks used by Bing. Supports redirect following.
-      private def http_get(url, accept_language: "en-US,en;q=0.9", follow_redirects: 0)
+      private def http_get(url, accept_language: "en-US,en;q=0.9", follow_redirects: 0, referer: nil)
         request = Net::HTTP::Get.new(url)
         request["User-Agent"] = USER_AGENTS.sample
         request["Accept"] = "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
@@ -208,8 +258,9 @@ module Clacky
         # a JS-only skeleton (~39KB) instead of the real HTML results (~120KB)
         request["Sec-Fetch-Dest"] = "document"
         request["Sec-Fetch-Mode"] = "navigate"
-        request["Sec-Fetch-Site"] = "none"
+        request["Sec-Fetch-Site"] = referer ? "same-origin" : "none"
         request["Upgrade-Insecure-Requests"] = "1"
+        request["Referer"] = referer if referer
 
         response = Net::HTTP.start(url.hostname, url.port,
           use_ssl: url.scheme == "https",
@@ -220,7 +271,7 @@ module Clacky
         if follow_redirects > 0 && response.is_a?(Net::HTTPRedirection)
           location = response["location"]
           redirect_url = location.start_with?("http") ? URI(location) : URI("#{url.scheme}://#{url.hostname}#{location}")
-          return http_get(redirect_url, accept_language: accept_language, follow_redirects: follow_redirects - 1)
+          return http_get(redirect_url, accept_language: accept_language, follow_redirects: follow_redirects - 1, referer: referer)
         end
 
         response

data/lib/clacky/ui2/layout_manager.rb

@@ -119,18 +119,29 @@ module Clacky
 
         @render_mutex.synchronize do
           entry = @buffer.entry_by_id(id)
-          # Skip if gone, fully committed, or only partially visible (its
-          # prefix is already in terminal scrollback and cannot be edited).
-          return if entry.nil? || entry.committed
-          return if (entry.committed_line_offset || 0) > 0
+          if entry.nil?
+            Clacky::Logger.warn("[ph_debug] replace_entry_nil", id: id, content: content.to_s[0, 120])
+            return
+          end
+          if entry.committed
+            Clacky::Logger.warn("[ph_debug] replace_entry_committed", id: id, content: content.to_s[0, 120])
+            return
+          end
+          if (entry.committed_line_offset || 0) > 0
+            Clacky::Logger.warn("[ph_debug] replace_entry_partial", id: id, offset: entry.committed_line_offset, content: content.to_s[0, 120])
+            return
+          end
 
           old_lines = entry.lines.dup
           new_lines = wrap_content_to_lines(content)
           if old_lines == new_lines
+            Clacky::Logger.warn("[ph_debug] replace_entry_same", id: id)
             screen.flush
             return
           end
           @buffer.replace(id, new_lines)
+          is_tail = @buffer.live_entries.last&.id == id
+          Clacky::Logger.warn("[ph_debug] replace_entry_paint", id: id, is_tail: is_tail, old_n: old_lines.length, new_n: new_lines.length, content: content.to_s[0, 120])
 
           unless @fullscreen_mode
             # repaint_entry_in_place relies on the entry being the tail of
@@ -147,7 +158,6 @@ module Clacky
             # For non-tail replaces, fall back to a full rebuild of the
             # output area from the buffer. Slower, but correct regardless
             # of where the entry lives.
-            is_tail = @buffer.live_entries.last&.id == id
             if is_tail
               repaint_entry_in_place(entry, old_lines, new_lines)
             else

data/lib/clacky/ui2/progress_handle.rb

@@ -177,8 +177,12 @@ module Clacky
       # @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)
         snapshot = @monitor.synchronize do
-          return if @state != :running
+          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 }
         end
@@ -194,7 +198,9 @@ module Clacky
           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])
         @owner.unregister_progress(self, final_frame: final_frame)
+        Clacky::Logger.warn("[ph_debug] finish_done", oid: object_id)
       end
       alias_method :cancel, :finish
 

data/lib/clacky/ui2/ui_controller.rb

@@ -655,6 +655,7 @@ module Clacky
 
       # Called by ProgressHandle#finish.
       def unregister_progress(handle, final_frame:)
+        Clacky::Logger.warn("[ph_debug] unreg_entry", oid: handle.object_id, eid: handle.entry_id, top: @progress_stack.last == handle, stack_size: @progress_stack.size, ff: final_frame.to_s[0, 200])
         @progress_mutex.synchronize do
           # If this handle still holds its entry (it's currently top), we
           # render one last frame there and release the id. If it was
@@ -662,10 +663,14 @@ module Clacky
           # is already gone and the final_frame is simply dropped.
           if handle.entry_id
             if final_frame && !final_frame.to_s.strip.empty?
+              Clacky::Logger.warn("[ph_debug] unreg_update_entry", oid: handle.object_id, eid: handle.entry_id)
               update_entry(handle.entry_id, @renderer.render_progress(final_frame))
             else
+              Clacky::Logger.warn("[ph_debug] unreg_remove_entry", oid: handle.object_id, eid: handle.entry_id)
               remove_entry(handle.entry_id)
             end
+          else
+            Clacky::Logger.warn("[ph_debug] unreg_no_entry_id", oid: handle.object_id)
           end
 
           @progress_stack.delete(handle)
@@ -873,6 +878,28 @@ module Clacky
         append_output(output)
       end
 
+      def phase_start(kind:, label:)
+        phase_id = SecureRandom.uuid
+        @active_phases ||= {}
+        @active_phases[phase_id] = { kind: kind, label: label, started_at: Time.now }
+        Thread.current[:clacky_phase_id] = phase_id
+
+        banner = "──────── ▼ #{label} ────────"
+        append_output(@renderer.render_system_message(banner, prefix_newline: true))
+        phase_id
+      end
+
+      def phase_end(phase_id, summary: nil)
+        Thread.current[:clacky_phase_id] = nil
+        return unless @active_phases&.key?(phase_id)
+
+        info = @active_phases.delete(phase_id)
+        label = info[:label]
+        tail = summary && !summary.to_s.strip.empty? ? " — #{summary.to_s.strip}" : ""
+        banner = "──────── ▲ #{label} done#{tail} ────────"
+        append_output(@renderer.render_system_message(banner, prefix_newline: false))
+      end
+
       # Set workspace status to idle (called when agent stops working)
       def set_idle_status
         # Safety net: close any legacy progress slots that were opened via

data/lib/clacky/ui_interface.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "securerandom"
+
 module Clacky
   # UIInterface defines the standard interface between Agent/CLI and UI implementations.
   # All UI controllers (UIController, JsonUIController) must implement these methods.
@@ -136,5 +138,25 @@ module Clacky
     # === Path redaction (for encrypted brand skill tmpdirs) ===
     # === Lifecycle ===
     def stop(clear_screen: false); end
+
+    # === Phase grouping (optional, web UI uses this to fold subagent runs) ===
+    # Begin a logical phase. Events emitted between phase_start and phase_end
+    # carry the phase_id so the UI can group them visually.
+    # Returns the phase_id (caller is responsible for passing it to phase_end).
+    def phase_start(kind:, label: nil)
+      SecureRandom.uuid
+    end
+
+    def phase_end(phase_id, summary: nil); end
+
+    # Run block within a phase. Always closes via ensure.
+    def with_phase(kind:, label: nil)
+      pid = phase_start(kind: kind, label: label)
+      begin
+        yield pid
+      ensure
+        phase_end(pid)
+      end
+    end
   end
 end

data/lib/clacky/utils/model_pricing.rb

@@ -145,6 +145,47 @@ module Clacky
         }
       },
 
+      # Xiaomi MiMo — USD per 1M tokens, international (海外) list price.
+      # Source: https://platform.xiaomimimo.com/docs/zh-CN/price/pay-as-you-go
+      # Effective 2026-05-27 (V2.5 launch price cut). Cache write is "limited-
+      # time free" per Xiaomi's notice; per the project's "displayed ≤ actual"
+      # convention we bill writes at the input-miss rate so that when the
+      # promo ends users won't see a cost spike. Cache hits use the explicit
+      # cache-hit rate.
+      #
+      # As of 2026-06-01, mimo-v2-pro/omni are forwarded to the V2.5 series
+      # and billed at V2.5 rates; mimo-v2-pro mirrors mimo-v2.5-pro and
+      # mimo-v2-omni mirrors mimo-v2.5. Both will be retired 2026-06-30.
+      "mimo-v2.5-pro" => {
+        input:  { default: 0.435,   over_200k: 0.435 },
+        output: { default: 0.87,    over_200k: 0.87 },
+        cache:  { write: 0.435,     read: 0.0036 }
+      },
+
+      "mimo-v2.5" => {
+        input:  { default: 0.14,    over_200k: 0.14 },
+        output: { default: 0.28,    over_200k: 0.28 },
+        cache:  { write: 0.14,      read: 0.0028 }
+      },
+
+      "mimo-v2-pro" => {
+        input:  { default: 0.435,   over_200k: 0.435 },
+        output: { default: 0.87,    over_200k: 0.87 },
+        cache:  { write: 0.435,     read: 0.0036 }
+      },
+
+      "mimo-v2-omni" => {
+        input:  { default: 0.14,    over_200k: 0.14 },
+        output: { default: 0.28,    over_200k: 0.28 },
+        cache:  { write: 0.14,      read: 0.0028 }
+      },
+
+      "mimo-v2-flash" => {
+        input:  { default: 0.10,    over_200k: 0.10 },
+        output: { default: 0.30,    over_200k: 0.30 },
+        cache:  { write: 0.10,      read: 0.01 }
+      },
+
       # Kimi K2.5 / K2.6 multimodal models
       # Source: https://platform.moonshot.cn (USD / 1M tokens)
       # Kimi billing model (same shape as DeepSeek):
@@ -181,6 +222,38 @@ module Clacky
         }
       },
 
+      # Google Gemini 3 series (via Vertex AI). Tiered at 200K input tokens
+      # for Pro; Flash has flat pricing.
+      "gemini-3.1-pro" => {
+        input: {
+          default: 2.00,
+          over_200k: 4.00
+        },
+        output: {
+          default: 12.00,
+          over_200k: 18.00
+        },
+        cache: {
+          write: 2.00,
+          read: 0.50
+        }
+      },
+
+      "gemini-3-flash" => {
+        input: {
+          default: 0.50,
+          over_200k: 0.50
+        },
+        output: {
+          default: 3.00,
+          over_200k: 3.00
+        },
+        cache: {
+          write: 0.50,
+          read: 0.05
+        }
+      },
+
       # OpenAI GPT-5.5 / GPT-5.4 — breakpoint at 272K input tokens
       # Source: https://openai.com/api/pricing/ (USD / 1M tokens)
       # Note: OpenAI's actual tiered-pricing threshold is 272K, not the
@@ -581,6 +654,22 @@ module Clacky
         # non-thinking / thinking modes respectively. Bill at flash rates.
         when /^deepseek-chat$/i, /^deepseek-reasoner$/i
           "deepseek-v4-flash"
+        # Xiaomi MiMo — strict anchored match per registered model id in
+        # providers.rb (currently mimo-v2.5-pro / mimo-v2-pro / mimo-v2-omni).
+        # mimo-v2.5 / mimo-v2-flash are also priced ahead of provider-side
+        # registration. Per Xiaomi's 2026-06 schedule, mimo-v2-pro/omni are
+        # transparently routed to V2.5 — keys are listed independently so
+        # both old and new ids resolve to the right rate.
+        when /^mimo-v2\.?5-pro$/i
+          "mimo-v2.5-pro"
+        when /^mimo-v2\.?5$/i
+          "mimo-v2.5"
+        when /^mimo-v2-pro$/i
+          "mimo-v2-pro"
+        when /^mimo-v2-omni$/i
+          "mimo-v2-omni"
+        when /^mimo-v2-flash$/i
+          "mimo-v2-flash"
         # Kimi K2.5 / K2.6 — strict match only. K2 text-only models
         # (kimi-k2-0905-preview, kimi-k2-thinking, etc.) are not yet
         # registered in providers.rb and will be added in a follow-up
@@ -636,6 +725,13 @@ module Clacky
         when /^qwen3-vl-plus$/i
           "qwen3-vl-plus"
 
+        # Google Gemini 3 series. Match the platform aliases (or-gemini-*)
+        # and the bare upstream ids returned by Vertex.
+        when /^or-gemini-3-1-pro$/i, /^gemini-3\.1-pro(-preview)?$/i
+          "gemini-3.1-pro"
+        when /^or-gemini-3-5-flash$/i, /^gemini-3\.5-flash$/i, /^gemini-3-flash(-preview)?$/i
+          "gemini-3-flash"
+
         # OpenAI GPT-5.x models — match various dashed/dotted/compact forms
         # (e.g. "gpt-5.5", "gpt-5-5", "gpt5.5", "gpt55")
         when /^gpt-?5\.?5$/i, /^gpt-?5[\.-]?5$/i

data/lib/clacky/version.rb

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