openclacky 1.5.6 → 1.5.8

data/lib/clacky/ui2/markdown_renderer.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "tty-markdown"
+require "tty-screen"
 require_relative "theme_manager"
 
 module Clacky
@@ -14,6 +14,10 @@ module Clacky
         def render(content)
           return content if content.nil? || content.empty?
 
+          # tty-markdown pulls in rouge + kramdown (~0.4s). Server mode renders
+          # markdown in the browser, so only pay that cost on a real terminal render.
+          require "tty-markdown" unless defined?(TTY::Markdown)
+
           # Get current theme colors
           theme = ThemeManager.current_theme
 

data/lib/clacky/ui2/progress_handle.rb

@@ -131,6 +131,7 @@ module Clacky
         @metadata      = {}
         @last_chunk_at = nil
         @monitor       = Monitor.new
+        @closed_cond   = @monitor.new_cond
       end
 
       # Start rendering. Registers with the owner (allocating an entry id
@@ -185,7 +186,10 @@ module Clacky
         snapshot = @monitor.synchronize do
           return if @unregistered
           first_close = @state == :running
-          @state = :closed if first_close
+          if first_close
+            @state = :closed
+            @closed_cond.broadcast
+          end
           {
             first_close: first_close,
             message: final_message || @message,
@@ -205,6 +209,21 @@ module Clacky
       end
       alias_method :cancel, :finish
 
+      # Close without leaving any trace: the owner removes the entry instead
+      # of committing a final frame. For work whose outcome was "nothing to
+      # report", where a lingering line is pure noise.
+      def discard
+        @monitor.synchronize do
+          return if @unregistered
+          @state = :closed
+          @closed_cond.broadcast
+        end
+
+        stop_ticker
+        @owner.unregister_progress(self, final_frame: nil)
+        @monitor.synchronize { @unregistered = true }
+      end
+
       # True while the ticker thread is alive.
       def ticker_alive?
         t = @ticker
@@ -261,8 +280,13 @@ module Clacky
           Thread.current.name = "progress-ticker-#{object_id}"
           begin
             loop do
-              sleep @tick_interval
-              break if @monitor.synchronize { @state != :running }
+              # wait, not sleep: finish/discard signals the condition so a
+              # long tick_interval never delays shutdown.
+              closed = @monitor.synchronize do
+                @closed_cond.wait(@tick_interval) if @state == :running
+                @state != :running
+              end
+              break if closed
               render_now
             end
           rescue StandardError

data/lib/clacky/ui2/ui_controller.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pastel"
 require_relative "layout_manager"
 require_relative "view_renderer"
 require_relative "progress_handle"
@@ -226,6 +227,9 @@ module Clacky
       # trigger a full output repaint (visible flicker) and the visual
       # order would have business messages appearing below the spinner.
       def append_output(content)
+        return nil if Thread.current[:clacky_chore_phase]
+
+        content = prefix_with_phase_label(content)
         @progress_mutex.synchronize do
           top = @progress_stack.last
           if top && top.entry_id
@@ -249,6 +253,17 @@ module Clacky
         @layout.append_output(content)
       end
 
+      # With several phases running at once the CLI's line-oriented output
+      # interleaves, so each line needs its origin stamped on it. A single
+      # active phase reads fine unprefixed (the banners already delimit it).
+      private def prefix_with_phase_label(content)
+        label = Thread.current[:clacky_phase_label]
+        return content unless label
+
+        tag = "[#{label}] "
+        content.to_s.split("\n", -1).map { |line| line.empty? ? line : "#{tag}#{line}" }.join("\n")
+      end
+
       # Log message to output area (use instead of puts)
       # @param message [String] Message to log
       # @param level [Symbol] Log level (:debug, :info, :warning, :error)
@@ -392,6 +407,8 @@ module Clacky
       # @param path [String] File path
       # @param is_new_file [Boolean] Whether this is a new file
       def show_file_write_preview(path, is_new_file:)
+        return if chore_capture(:file, path)
+
         theme = ThemeManager.current_theme
         file_label = theme.format_symbol(:file)
         status = is_new_file ? theme.format_text("Creating new file", :success) : theme.format_text("Modifying existing file", :warning)
@@ -402,6 +419,8 @@ module Clacky
       # Show file operation preview (Edit tool)
       # @param path [String] File path
       def show_file_edit_preview(path)
+        return if chore_capture(:file, path)
+
         theme = ThemeManager.current_theme
         file_label = theme.format_symbol(:file)
         append_output("\n#{file_label} #{path || '(unknown)'}")
@@ -410,6 +429,8 @@ module Clacky
       # Show file operation error
       # @param error_message [String] Error message
       def show_file_error(error_message)
+        return if chore_capture(:error, error_message)
+
         theme = ThemeManager.current_theme
         append_output("   #{theme.format_text("Warning:", :error)} #{error_message}")
       end
@@ -453,10 +474,69 @@ module Clacky
         filtered.strip
       end
 
+      # Record a noteworthy event that happened inside a chore phase. The raw
+      # transcript is suppressed (a line-oriented terminal has no folding),
+      # but the CLI still owes the user a digest — the collapsed-card
+      # equivalent of what the web UI lets you expand.
+      #
+      # @return [Boolean] true if a chore phase absorbed it.
+      private def chore_capture(kind, text)
+        return false unless Thread.current[:clacky_chore_phase]
+        text = text.to_s.strip
+        return true if text.empty?
+
+        @phase_mutex ||= Mutex.new
+        @phase_mutex.synchronize do
+          @chore_digest ||= { tools: Hash.new(0), files: [], errors: [] }
+          case kind
+          when :tool  then @chore_digest[:tools][text] += 1
+          when :file  then @chore_digest[:files] << text unless @chore_digest[:files].include?(text)
+          when :error then @chore_digest[:errors] << text
+          end
+        end
+        true
+      end
+
+      # Turn the captured digest into the handful of lines the CLI prints
+      # after a chore finishes. Errors are always listed in full; tools and
+      # files are condensed, since a memory update touching 20 files should
+      # not out-scroll the answer the user actually asked for.
+      private def chore_digest_lines
+        @phase_mutex ||= Mutex.new
+        digest = @phase_mutex.synchronize { @chore_digest }
+        return [] if digest.nil?
+
+        lines = []
+        digest[:files].first(CHORE_DIGEST_MAX_FILES).each { |f| lines << "· #{f}" }
+        if (extra = digest[:files].size - CHORE_DIGEST_MAX_FILES) > 0
+          lines << "· …#{extra} more file#{"s" if extra > 1}"
+        end
+
+        if digest[:tools].any?
+          total = digest[:tools].values.sum
+          ranked = digest[:tools].sort_by { |_n, c| -c }
+          names = ranked.first(CHORE_DIGEST_MAX_TOOLS).map do |name, count|
+            count > 1 ? "#{name}×#{count}" : name
+          end
+          if (extra = ranked.size - CHORE_DIGEST_MAX_TOOLS) > 0
+            names << "+#{extra} more"
+          end
+          lines << "· #{total} tool call#{"s" if total > 1}: #{names.join(", ")}"
+        end
+
+        digest[:errors].first(CHORE_DIGEST_MAX_ERRORS).each { |e| lines << "! #{e}" }
+        if (extra = digest[:errors].size - CHORE_DIGEST_MAX_ERRORS) > 0
+          lines << "! …#{extra} more error#{"s" if extra > 1}"
+        end
+        lines
+      end
+
       # Show tool call
       # @param name [String] Tool name
       # @param args [String, Hash] Tool arguments (JSON string or Hash)
       def show_tool_call(name, args)
+        return if chore_capture(:tool, name)
+
         # Reset stdout buffer on each new tool call so previous command output
         # doesn't bleed into the next one, and so the buffer is ready before
         # on_output starts firing (which can happen before show_progress is called).
@@ -506,6 +586,8 @@ module Clacky
       # @param error [String, Exception] Error message or exception
       def show_tool_error(error)
         error_msg = error.is_a?(Exception) ? error.message : error.to_s
+        return if chore_capture(:error, error_msg)
+
         output = @renderer.render_tool_error(error: error_msg)
         append_output(output)
       end
@@ -655,6 +737,22 @@ module Clacky
 
       # Called by ProgressHandle#start.
       def register_progress(handle)
+        # Inside a chore phase only the phase's own indicator occupies a line.
+        # Nested handles (the subagent's LLM calls and tool runs) get no entry
+        # of their own — otherwise each one commits a permanent final frame on
+        # finish, since unregister_progress writes straight into the buffer and
+        # never passes through append_output's chore gate. Their activity is
+        # instead folded into the chore line by +fold_into_chore_line+.
+        if Thread.current[:clacky_chore_phase] && @chore_progress
+          @progress_mutex.synchronize do
+            @chore_nested ||= []
+            @chore_nested << handle
+            @chore_steps = @chore_steps.to_i + 1 if handle.style == :primary
+            fold_into_chore_line(handle)
+          end
+          return nil
+        end
+
         @progress_mutex.synchronize do
           prev_top = @progress_stack.last
           if prev_top
@@ -675,6 +773,17 @@ module Clacky
       # Called by ProgressHandle#finish.
       def unregister_progress(handle, final_frame:)
         @progress_mutex.synchronize do
+          if @chore_nested&.delete(handle)
+            # Folded handles own no entry; hand the chore line back to
+            # whatever is still running underneath (or the bare label).
+            fold_into_chore_line(@chore_nested.last)
+            next
+          end
+
+          # A handle that was never stacked owns nothing here: restoring
+          # "the new top" would duplicate what is legitimately on screen.
+          next unless @progress_stack.include?(handle)
+
           if handle.entry_id
             if final_frame && !final_frame.to_s.strip.empty?
               update_entry(handle.entry_id, @renderer.render_progress(final_frame))
@@ -705,6 +814,19 @@ module Clacky
       # +register_progress+).
       def render_frame(handle, frame)
         @progress_mutex.synchronize do
+          if @chore_nested&.include?(handle)
+            fold_into_chore_line(handle)
+            return
+          end
+
+          # The chore's own ticker must render the folded view too, otherwise
+          # every tick repaints the bare label and the line flickers between
+          # "<label>…" and "<label> · <activity>…".
+          if @chore_progress && @chore_progress == handle && @chore_nested&.any?
+            fold_into_chore_line(@chore_nested.last)
+            return
+          end
+
           return unless @progress_stack.last == handle
           return unless handle.entry_id
 
@@ -726,6 +848,27 @@ module Clacky
         end
       end
 
+      # Repaint the chore phase's single line to reflect the innermost nested
+      # activity: "<label> · <what it's doing> (Ns · step K)". Keeps the user
+      # informed without letting the chore's subagent spam one permanent line
+      # per LLM call. Must be called with @progress_mutex held.
+      private def fold_into_chore_line(inner)
+        chore = @chore_progress
+        return unless chore&.entry_id
+
+        parts = [chore.message]
+        parts << inner.message.to_s.strip if inner && !inner.message.to_s.strip.empty?
+
+        suffix = []
+        elapsed = chore.start_time ? (Time.now - chore.start_time).to_i : 0
+        suffix << "#{elapsed}s" if elapsed > 0
+        suffix << "step #{@chore_steps}" if @chore_steps.to_i > 0
+
+        line = parts.join(" · ")
+        line = "#{line}… (#{suffix.join(" · ")})" unless suffix.empty?
+        update_entry(chore.entry_id, @renderer.render_progress(line))
+      end
+
       # Render the very first frame of +handle+ (used when registering or
       # restoring). Mirrors +render_frame+'s formatting minus the implicit
       # elapsed-time tick (handle hasn't ticked yet).
@@ -888,28 +1031,86 @@ module Clacky
         append_output(output)
       end
 
-      def phase_start(kind:, label:)
+      # Phases the user never asked for: post-task chores that run after the
+      # answer is already on screen. The web UI folds them into a card; a
+      # line-oriented terminal has no folding, so their transcript is
+      # swallowed and only a one-line progress indicator remains.
+      CHORE_PHASE_KINDS = %w[memory_update skill_evolution].freeze
+
+      # Caps for the post-chore digest. A chore is background work the user
+      # never asked for, so its recap must stay far shorter than the answer.
+      CHORE_DIGEST_MAX_FILES = 5
+      CHORE_DIGEST_MAX_TOOLS = 4
+      CHORE_DIGEST_MAX_ERRORS = 3
+
+      def phase_start(kind:, label:, concurrent: false)
         phase_id = SecureRandom.uuid
-        @active_phases ||= {}
-        @active_phases[phase_id] = { kind: kind, label: label, started_at: Time.now }
+        chore = CHORE_PHASE_KINDS.include?(kind.to_s) && !verbose_phases?
+        @phase_mutex ||= Mutex.new
+        @phase_mutex.synchronize do
+          @active_phases ||= {}
+          @active_phases[phase_id] = { kind: kind, label: label, started_at: Time.now, chore: chore }
+        end
         Thread.current[:clacky_phase_id] = phase_id
 
+        if chore
+          # Start the indicator before arming the gate: this handle is the
+          # one thing that stays visible during the chore.
+          @chore_progress = start_progress(message: label, style: :quiet)
+          Thread.current[:clacky_chore_phase] = phase_id
+          return phase_id
+        end
+
         banner = "──────── ▼ #{label} ────────"
         append_output(@renderer.render_system_message(banner, prefix_newline: true))
+        # Only concurrent phases interleave, so only they need per-line tagging.
+        Thread.current[:clacky_phase_label] = concurrent ? label : nil
         phase_id
       end
 
       def phase_end(phase_id, summary: nil)
-        Thread.current[:clacky_phase_id] = nil
-        return unless @active_phases&.key?(phase_id)
+        Thread.current[:clacky_phase_id] = nil if Thread.current[:clacky_phase_id] == phase_id
+        Thread.current[:clacky_phase_label] = nil
+        @phase_mutex ||= Mutex.new
+        info = @phase_mutex.synchronize { @active_phases&.delete(phase_id) }
+        return unless info
 
-        info = @active_phases.delete(phase_id)
         label = info[:label]
+
+        if info[:chore]
+          Thread.current[:clacky_chore_phase] = nil
+          handle = @chore_progress
+          @chore_progress = nil
+          @chore_nested = nil
+          @chore_steps = 0
+          handle&.discard
+
+          digest = chore_digest_lines
+          @phase_mutex.synchronize { @chore_digest = nil }
+
+          # No summary and nothing captured means nothing worth reporting
+          # happened (the common "no memory updates needed" path) — leave no
+          # trace at all.
+          has_summary = summary && !summary.to_s.strip.empty?
+          return if !has_summary && digest.empty?
+
+          elapsed = (Time.now - info[:started_at]).round
+          head = has_summary ? "#{label} — #{summary.to_s.strip} (#{elapsed}s)" : "#{label} (#{elapsed}s)"
+          append_output(@renderer.render_system_message(head, prefix_newline: false))
+          theme = ThemeManager.current_theme
+          digest.each { |line| append_output(theme.format_text("    #{line}", :thinking)) }
+          return
+        end
+
         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
 
+      private def verbose_phases?
+        @config.respond_to?(:verbose) && @config.verbose
+      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

@@ -159,19 +159,29 @@ module Clacky
     # === Lifecycle ===
     def stop(clear_screen: false); end
 
+    # === Custom events (extension bus) ===
+    # Push an arbitrary typed event to the UI transport. Streaming UIs (web,
+    # json) override this; UIs with no event channel (CLI, null) drop it.
+    #
+    # Extensions must namespace `type` as "ext.<extension>.<event>" so custom
+    # events never collide with the built-in protocol. The web UI forwards
+    # namespaced events straight to the `Clacky.ext` bus, where a subscriber
+    # receives them under that same name.
+    def emit(type, **data); 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)
+    def phase_start(kind:, label: nil, concurrent: false)
       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)
+    def with_phase(kind:, label: nil, concurrent: false)
+      pid = phase_start(kind: kind, label: label, concurrent: concurrent)
       begin
         yield pid
       ensure

data/lib/clacky/utils/arguments_parser.rb

@@ -88,12 +88,78 @@ module Clacky
         result
       end
 
+      # Undo one layer of accidental double-serialization, guided by the tool's
+      # parameter schema.
+      #
+      # Some LLMs (e.g. glm-5.2) emit array/object parameters as a JSON *string*
+      # (e.g. {"task":"[\"a\",\"b\"]"}) instead of a native JSON value. JSON.parse
+      # only strips the outer layer, so such values arrive here as a literal
+      # String and break downstream tools that expect an Array/Hash.
+      #
+      # To stay safe we rely on the declared schema type instead of a blind
+      # "looks like JSON" heuristic:
+      #   - a parameter declared `type: "string"` is NEVER parsed, so a value
+      #     that merely happens to be valid JSON text (file content, a code
+      #     snippet, a JSON blob to be written) is preserved verbatim;
+      #   - a parameter declared `type: "array"`/`"object"` that still arrives
+      #     as a String is unwrapped exactly once;
+      #   - additionally, when a concrete type IS declared, the parsed result
+      #     must match it (an array-typed param that receives a JSON object
+      #     string is left untouched rather than silently coerced to a Hash);
+      #   - a parameter with no declared `type` (e.g. flexible params such as
+      #     todo_manager's task/id, which may be a scalar or a list) falls back
+      #     to a conservative heuristic: unwrap only if the stripped value
+      #     starts with "["/"{" and parses cleanly.
+      # Strings that fail JSON.parse are always left untouched.
+      def self.undouble_serialize_args(args, properties = {})
+        args.to_h do |key, value|
+          expected = schema_type(properties, key)
+          # Explicit string params: never unwrap (protects content / code / JSON text).
+          next [key, value] if expected == "string"
+          # Scalar-typed params (integer/number/boolean): no JSON shape to recover.
+          next [key, value] if expected && expected != "array" && expected != "object"
+          # For array/object/untyped params, only unwrap a String that looks like JSON.
+          next [key, value] unless value.is_a?(String)
+          stripped = value.strip
+          next [key, value] unless stripped.start_with?("[") || stripped.start_with?("{")
+          begin
+            # symbolize_names keeps unwrapped Hash keys consistent with the
+            # outer JSON.parse(call[:arguments], symbolize_names: true).
+            parsed = JSON.parse(value, symbolize_names: true)
+            # Type-match guard: if the schema declares a concrete type, the
+            # parsed value must match it. Prevents silently turning a Hash into
+            # an Array (or vice-versa) when an array-typed param receives a
+            # JSON object string, etc.
+            if expected == "array" && !parsed.is_a?(Array)
+              next [key, value]
+            elsif expected == "object" && !parsed.is_a?(Hash)
+              next [key, value]
+            end
+            [key, parsed]
+          rescue JSON::ParserError
+            [key, value]
+          end
+        end
+      end
+
+      # Look up a parameter's declared JSON-Schema type, tolerating string/symbol
+      # keys in both +properties+ and the per-param spec hash.
+      def self.schema_type(properties, key)
+        spec = properties[key] || properties[key.to_s] || properties[key.to_sym]
+        return nil unless spec.is_a?(Hash)
+        spec[:type] || spec["type"]
+      end
+
       # Validate required parameters and filter unknown parameters
       def self.validate_required_params(call, args, tool_registry)
         tool = tool_registry.get(call[:name])
         required = tool.parameters&.dig(:required) || []
         properties = tool.parameters&.dig(:properties) || {}
 
+        # Undo accidental double-serialization BEFORE filtering, using the schema
+        # so that parameters declared as "string" are never touched.
+        args = undouble_serialize_args(args, properties)
+
         missing = required.reject { |param|
           args.key?(param.to_sym) || args.key?(param.to_s)
         }
@@ -161,11 +227,14 @@ module Clacky
         lines << "  Name: #{tool.name}"
         lines << "  Description: #{tool.description}"
 
-        if tool.parameters[:properties]
+        params = tool.parameters
+        properties = params && params[:properties]
+        if properties
           lines << "  Parameters:"
-          tool.parameters[:properties].each do |param, spec|
-            required_mark = tool.parameters[:required]&.include?(param.to_s) ? " (required)" : ""
-            lines << "    - #{param}#{required_mark}: #{spec[:description]}"
+          properties.each do |param, spec|
+            required_mark = params[:required]&.include?(param.to_s) ? " (required)" : ""
+            desc = spec.is_a?(Hash) ? spec[:description] : spec.to_s
+            lines << "    - #{param}#{required_mark}: #{desc}"
           end
         end
 

data/lib/clacky/utils/model_pricing.rb

@@ -377,6 +377,25 @@ module Clacky
         }
       },
 
+      # Gemini 3.6 Flash (GA 2026-07-21). Flat pricing, 1M context, 64K max output.
+      # Source: https://deepmind.google/models/gemini/flash/
+      # Cache write billed at input rate (Vertex doesn't expose a separate
+      # cache-write charge in the OpenAI shim usage response).
+      "gemini-3.6-flash" => {
+        input: {
+          default: 1.50,
+          over_200k: 1.50
+        },
+        output: {
+          default: 7.50,
+          over_200k: 7.50
+        },
+        cache: {
+          write: 1.50,
+          read: 0.15
+        }
+      },
+
       # 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
@@ -882,6 +901,8 @@ module Clacky
           "gemini-3.1-pro"
         when /^or-gemini-3-5-flash$/i, /^gemini-3\.5-flash$/i, /^gemini-3-flash(-preview)?$/i
           "gemini-3-flash"
+        when /^or-gemini-3-6-flash$/i, /^gemini-3\.6-flash$/i
+          "gemini-3.6-flash"
 
         # OpenAI GPT-5.x models — match various dashed/dotted/compact forms
         # (e.g. "gpt-5.5", "gpt-5-5", "gpt5.5", "gpt55")

data/lib/clacky/version.rb

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