openclacky 1.5.6 → 1.5.8

data/lib/clacky/agent/memory_updater.rb

@@ -68,20 +68,23 @@ module Clacky
       def run_memory_update_subagent
         return unless should_update_memory?
 
-        with_memory_update_phase do
-          run_memory_update_subagent_inner
-        end
+        with_memory_update_phase { run_memory_update_subagent_inner }
       end
 
       private def with_memory_update_phase
         return yield unless @ui.respond_to?(:with_phase)
 
-        @ui.with_phase(kind: "memory_update", label: "Updating long-term memory") { yield }
+        pid = @ui.phase_start(kind: "memory_update", label: "Updating long-term memory")
+        summary = nil
+        begin
+          summary = yield
+        ensure
+          @ui.phase_end(pid, summary: summary)
+        end
+        summary
       end
 
       private def run_memory_update_subagent_inner
-        handle = @ui&.start_progress(message: "Updating long-term memory…", style: :primary)
-
         # Fork subagent inheriting main agent's model, tools, and history.
         # Maximizes prompt-cache reuse: same model, same tool set, same
         # cloned history — only the +system_prompt_suffix+ (the memory
@@ -114,8 +117,6 @@ module Clacky
           }
           Clacky::Logger.error("memory_update_error", error: e)
           return
-        ensure
-          handle&.finish
         end
 
         return unless result
@@ -124,16 +125,14 @@ module Clacky
         # sessionbar shows the real total. The parent's task-complete cost
         # (result[:total_cost_usd] in Agent#run) stays unaffected — it
         # still reflects ONLY the user's task, not the memory update.
-        subagent_cost = result[:total_cost_usd] || 0.0
-        @total_cost += subagent_cost
-        @ui&.update_sessionbar(cost: @total_cost, cost_source: @cost_source)
-
-        # Only surface a completion info line if the subagent actually
-        # wrote something to memory. The common "No memory updates needed."
-        # path stays silent to avoid visual noise.
-        if subagent_wrote_memory?(subagent)
-          @ui&.show_info("Memory updated: #{result[:iterations]} iterations, $#{subagent_cost.round(4)}")
-        end
+        subagent_cost = absorb_subagent_cost(result)
+
+        # A summary is only worth showing if the subagent actually wrote
+        # something. The common "No memory updates needed." path returns nil
+        # so the phase leaves no trace at all.
+        return unless subagent_wrote_memory?(subagent)
+
+        "#{result[:iterations]} steps · $#{subagent_cost.round(4)}"
       end
 
       private def memory_update_enabled?

data/lib/clacky/agent/message_compressor_helper.rb

@@ -628,6 +628,7 @@ module Clacky
             lines << ""
             lines << format_message_content(content)
             lines << ""
+            append_ext_events_line(lines, msg)
           when "assistant"
             # If this message is itself a compressed summary, annotate the header
             # so the reader knows the original conversation is in the referenced chunk
@@ -660,6 +661,7 @@ module Clacky
             end
             lines << format_message_content(content) if content
             lines << ""
+            append_ext_events_line(lines, msg)
           when "tool"
             tool_name = msg[:name] || "tool"
             lines << "### Tool Result: #{tool_name}"
@@ -668,11 +670,32 @@ module Clacky
             lines << truncate_content(content.to_s, max_length: 500)
             lines << "```"
             lines << ""
+            append_ext_events_line(lines, msg)
           end
         end
         lines
       end
 
+      # Serialize persisted extension events into the chunk MD so they survive
+      # compression and can be replayed in place. Mirrors the "_Tool calls:"
+      # convention; parse_chunk_md_to_rounds reads it back.
+      def append_ext_events_line(lines, msg)
+        events = Array(msg[:ext_events])
+        return if events.empty?
+
+        parts = events.filter_map do |ev|
+          type = ev[:type] || ev["type"]
+          next nil if type.nil? || type.to_s.empty?
+
+          data = ev[:data] || ev["data"] || {}
+          "#{type} | #{data.to_json}"
+        end
+        return if parts.empty?
+
+        lines << "_Ext events: #{parts.join("; ")}_"
+        lines << ""
+      end
+
       # Format message content (handles string or array of content blocks)
       def format_message_content(content)
         return "" if content.nil?

data/lib/clacky/agent/session_serializer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "strscan"
+
 module Clacky
   class Agent
     # Session serialization for saving and restoring agent state
@@ -11,7 +13,6 @@ module Clacky
         @session_id = session_data[:session_id]
         @name = session_data[:name] || ""
         @pinned = session_data[:pinned] || false
-        @hidden = session_data[:hidden] || false
         @history = MessageHistory.new(session_data[:messages] || [])
         @todos = session_data[:todos] || []  # Restore todos from session
         @iterations = session_data.dig(:stats, :total_iterations) || 0
@@ -226,7 +227,6 @@ module Clacky
           session_id: @session_id,
           name: @name,
           pinned: @pinned,
-          hidden: @hidden,
           created_at: @created_at,
           updated_at: (updated_at || @persisted_updated_at || Time.now.iso8601).then { |v| v.is_a?(String) ? v : v.iso8601 },
           working_dir: @working_dir,
@@ -393,6 +393,7 @@ module Clacky
           all_files = image_files + disk_files
           ui.show_user_message(raw_text, created_at: msg[:created_at], files: all_files,
                                editable: round[:editable] != false)
+          replay_ext_events(msg, ui)
 
           round[:events].each do |ev|
             # Skip system-injected messages (e.g. synthetic skill content, memory prompts)
@@ -522,6 +523,7 @@ module Clacky
 
         sections.each do |sec|
           text = sec[:lines].join.strip
+          text, sec_ext_events = extract_ext_events_from_text(text)
 
           # Nested chunk: expand it recursively, prepend before current rounds
           if sec[:nested_chunk]
@@ -534,7 +536,7 @@ module Clacky
             next
           end
 
-          next if text.empty?
+          next if text.empty? && sec_ext_events.empty?
 
           if sec[:role] == "user"
             round_index += 1
@@ -545,6 +547,7 @@ module Clacky
                 role: "user",
                 content: text,
                 created_at: synthetic_ts,
+                ext_events: sec_ext_events,
                 _from_chunk: true
               },
               events: [],
@@ -569,19 +572,7 @@ module Clacky
                 stripped = line.strip
                 if (m = stripped.match(/\A_Tool calls?:\s*(.+?)_?\z/i))
                   raw = m[1]
-                  # New format uses ";" as separator between tools (each entry: "name | {json}")
-                  # Old format uses "," with no JSON part.
-                  entries = raw.include?(" | ") ? raw.split(/;\s*/) : raw.split(/,\s*/)
-                  entries.each do |entry|
-                    entry = entry.strip
-                    if (parts = entry.match(/\A(.+?)\s*\|\s*(\{.+\})\z/))
-                      tool_name = parts[1].strip
-                      args = JSON.parse(parts[2]) rescue {}
-                      pending_tool_entries << { name: tool_name, args: args }
-                    else
-                      pending_tool_entries << { name: entry, args: {} }
-                    end
-                  end
+                  pending_tool_entries.concat(parse_tool_calls_line(raw))
                 else
                   remaining_lines << line
                 end
@@ -599,8 +590,11 @@ module Clacky
                   tool_calls: [{ name: entry[:name], arguments: entry[:args] }]
                 }
               end
+
+              attach_ext_events_to_last(current_round, sec_ext_events)
             else
               current_round[:events] << { role: "tool", content: text }
+              attach_ext_events_to_last(current_round, sec_ext_events)
             end
           end
         end
@@ -612,6 +606,108 @@ module Clacky
       end
 
 
+      # Pull the "_Ext events: type | {json}; ..._" line out of a chunk section,
+      # returning the remaining text plus the parsed events. Counterpart to
+      # MessageCompressorHelper#append_ext_events_line.
+      def extract_ext_events_from_text(text)
+        return [text, []] unless text.include?("_Ext events:")
+
+        events = []
+        kept = text.each_line.reject do |line|
+          m = line.strip.match(/\A_Ext events?:\s*(.+?)_?\z/i)
+          next false unless m
+
+          parse_piped_entries(m[1]).each do |entry|
+            next if entry[:args].nil?
+
+            events << { type: entry[:name], data: entry[:args] }
+          end
+          true
+        end
+
+        [kept.join.strip, events]
+      end
+
+      # Split a "_Tool calls:_" payload into entries. The separator ";" also
+      # occurs inside args JSON (shell commands, JS snippets), so entry
+      # boundaries are found by brace balancing rather than String#split.
+      def parse_tool_calls_line(raw)
+        parse_piped_entries(raw).map { |e| { name: e[:name], args: e[:args] || {} } }
+      end
+
+      # Scan a "name | {json}; name | {json}" payload. Shared by the
+      # "_Tool calls:" and "_Ext events:" chunk MD lines, whose ";" separator
+      # is ambiguous with semicolons inside the JSON values. Entries with no
+      # JSON payload yield args: nil so callers can tell "absent" from "empty".
+      def parse_piped_entries(raw)
+        return [] if raw.nil?
+
+        scanner = StringScanner.new(raw)
+        entries = []
+
+        until scanner.eos?
+          scanner.skip(/[;,]?\s*/)
+          break if scanner.eos?
+
+          name = scanner.scan(/[^|;,]+?(?=\s*\|\s*\{)/)
+          unless name
+            plain = scanner.scan(/[^;,]+/)
+            break unless plain
+
+            plain = plain.strip
+            entries << { name: plain, args: nil } unless plain.empty?
+            next
+          end
+
+          scanner.skip(/\s*\|\s*/)
+          json = scan_balanced_json(scanner)
+          next unless json
+
+          parsed = JSON.parse(json) rescue nil
+          entries << { name: name.strip, args: parsed.is_a?(Hash) ? parsed : {} }
+        end
+
+        entries
+      end
+
+      # Consume one balanced {...} literal, ignoring braces inside JSON strings.
+      def scan_balanced_json(scanner)
+        start = scanner.pos
+        return nil unless scanner.getch == "{"
+
+        depth = 1
+        in_string = false
+        escaped = false
+
+        while (ch = scanner.getch)
+          if escaped
+            escaped = false
+          elsif ch == "\\"
+            escaped = true
+          elsif ch == '"'
+            in_string = !in_string
+          elsif !in_string && ch == "{"
+            depth += 1
+          elsif !in_string && ch == "}"
+            depth -= 1
+            return scanner.string[start...scanner.pos] if depth.zero?
+          end
+        end
+
+        nil
+      end
+
+      # Anchor chunk-restored events to the last message of the round so they
+      # replay after it, matching where they were emitted live.
+      def attach_ext_events_to_last(round, events)
+        return if events.nil? || events.empty?
+
+        target = round[:events].last || round[:user_msg]
+        return unless target
+
+        target[:ext_events] = Array(target[:ext_events]) + events
+      end
+
       # Render a single non-user message into the UI.
       # Used by both the normal round-based replay and the compressed-session fallback.
       def _replay_single_message(msg, ui)
@@ -664,20 +760,38 @@ module Clacky
 
         when "user"
           # Anthropic-format tool results (role: user, content: array of tool_result blocks)
-          return unless msg[:content].is_a?(Array)
-
-          msg[:content].each do |blk|
-            next unless blk.is_a?(Hash) && blk[:type] == "tool_result"
+          if msg[:content].is_a?(Array)
+            msg[:content].each do |blk|
+              next unless blk.is_a?(Hash) && blk[:type] == "tool_result"
 
-            ui.show_tool_result(blk[:content].to_s)
+              ui.show_tool_result(blk[:content].to_s)
+            end
+            replay_subagent_transcript(msg, ui)
           end
-          replay_subagent_transcript(msg, ui)
 
         when "tool"
           # OpenAI-format tool result
           ui.show_tool_result(msg[:content].to_s)
           replay_subagent_transcript(msg, ui)
         end
+
+        replay_ext_events(msg, ui)
+      end
+
+      # Re-emit custom extension events recorded on a message so extension
+      # panels can rebuild their state after a page reload. Mirrors what
+      # Agent#emit_event pushed live. No-op when the message carries none.
+      def replay_ext_events(msg, ui)
+        Array(msg[:ext_events]).each do |ev|
+          next unless ev.is_a?(Hash)
+
+          type = ev[:type] || ev["type"]
+          next if type.nil? || type.to_s.empty?
+
+          data = ev[:data] || ev["data"] || {}
+          data = data.is_a?(Hash) ? data.transform_keys(&:to_sym) : {}
+          ui.emit(type.to_s, **data)
+        end
       end
 
       # Replay a subagent transcript stored on a tool result message. Emits a

data/lib/clacky/agent/skill_auto_creator.rb

@@ -20,11 +20,10 @@ module Clacky
       def maybe_create_skill_from_task
         return unless should_auto_create_skill?
 
-        @ui&.show_info("Analyzing task for skill creation opportunity...")
-
         # Fork an isolated subagent to evaluate + create — does NOT touch main history
         subagent = fork_subagent
         subagent.run(build_skill_creation_prompt)
+        nil
       end
 
       # Determine if this task is a candidate for skill auto-creation

data/lib/clacky/agent/skill_evolution.rb

@@ -26,10 +26,11 @@ module Clacky
       def run_skill_evolution_hooks
         return unless skill_evolution_enabled?
         return if @is_subagent
-        return unless skill_evolution_visible? || skill_evolution_has_work?
 
         with_skill_evolution_phase do
-          if @skill_execution_context
+          if !skill_evolution_has_work?
+            Clacky::I18n.t("phase.skipped")
+          elsif @skill_execution_context
             maybe_reflect_on_skill
           else
             maybe_create_skill_from_task
@@ -37,10 +38,6 @@ module Clacky
         end
       end
 
-      private def skill_evolution_visible?
-        @config.respond_to?(:verbose) && @config.verbose
-      end
-
       private def skill_evolution_has_work?
         if @skill_execution_context
           should_reflect_on_skill?
@@ -52,7 +49,14 @@ module Clacky
       private def with_skill_evolution_phase
         return yield unless @ui.respond_to?(:with_phase)
 
-        @ui.with_phase(kind: "skill_evolution", label: "Reflecting on this task") { yield }
+        pid = @ui.phase_start(kind: "skill_evolution", label: Clacky::I18n.t("phase.skill_evolution"))
+        summary = nil
+        begin
+          summary = yield
+        ensure
+          @ui.phase_end(pid, summary: summary)
+        end
+        summary
       end
 
       # Check if skill evolution is enabled in config

data/lib/clacky/agent/skill_manager.rb

@@ -576,8 +576,10 @@ module Clacky
       # Execute a skill in a forked subagent
       # @param skill [Skill] The skill to execute
       # @param arguments [String] Arguments for the skill
+      # @param tool_call_id [String, nil] The invoke_skill call this run belongs to;
+      #   nil for the slash-command path, which has no tool result to attach to.
       # @return [String] Summary of subagent execution
-      def execute_skill_with_subagent(skill, arguments)
+      def execute_skill_with_subagent(skill, arguments, tool_call_id: nil)
         touch_skill_for_lru(skill)
         # For encrypted brand skills with supporting scripts: decrypt to a tmpdir.
         # Subagent path has a clear boundary (subagent.run returns), so we shred inline
@@ -603,17 +605,22 @@ module Clacky
           system_prompt_suffix: skill_instructions
         )
 
-        # Log which model the subagent is actually using (may differ from requested
-        # when "lite" falls back to default due to no lite model configured)
-        @ui&.show_info("Subagent start: #{skill.identifier}#{skill.name_zh.to_s.empty? ? "" : " (#{skill.name_zh})"} [#{subagent.current_model_info[:model]}]")
-
         # Run subagent with the actual task as the sole user turn.
         # If the user typed the skill command with no arguments (e.g. "/jade-appraisal"),
         # use a generic trigger phrase so the user message is never empty.
         task_input = arguments.to_s.strip.empty? ? "Please proceed." : arguments
 
         begin
-          result = subagent.run(task_input)
+          # The model may differ from the requested one ("lite" falls back to
+          # default when no lite model is configured), so name it on the card.
+          phase_label = "#{skill.identifier} · #{subagent.current_model_info[:model]}"
+
+          result = within_phase(phase_label, kind: "subagent", concurrent: false) do
+            run_result = subagent.run(task_input)
+            cost = absorb_subagent_cost(run_result)
+            @ui&.show_info("Completed in #{run_result[:iterations]} iterations · $#{cost.round(4)}")
+            run_result
+          end
         rescue Clacky::AgentInterrupted
           # Subagent was interrupted by user (Ctrl+C).
           # Write an interrupted summary into history so the parent agent's history
@@ -642,9 +649,13 @@ module Clacky
         # Capture the subagent's own message trail (everything it appended after
         # the fork) so the parent session can persist and later replay the full
         # subagent process — not just the collapsed summary. Stored transiently
-        # on the parent agent; observe() attaches it to the invoke_skill tool
-        # result message. Kept out of the LLM payload via INTERNAL_FIELDS.
-        @pending_subagent_transcript = extract_subagent_transcript(subagent, skill.identifier)
+        # on the parent agent, keyed by the invoke_skill call it belongs to;
+        # observe() attaches each trail to its own tool result message.
+        # Kept out of the LLM payload via INTERNAL_FIELDS.
+        if tool_call_id
+          @pending_subagent_transcripts[tool_call_id] =
+            extract_subagent_transcript(subagent, skill.identifier)
+        end
 
         # Mutate the subagent_instructions message in-place to become the result summary
         @history.mutate_last_matching(->(m) { m[:subagent_instructions] }) do |m|
@@ -654,15 +665,6 @@ module Clacky
           m[:skill_name] = skill.identifier
         end
 
-        # Merge subagent cost into parent agent's total so the sessionbar reflects
-        # the real cumulative spend across all subagents
-        subagent_cost = result[:total_cost_usd] || 0.0
-        @total_cost += subagent_cost
-        @ui&.update_sessionbar(cost: @total_cost, cost_source: @cost_source)
-
-        # Log completion
-        @ui&.show_info("Subagent completed: #{result[:iterations]} iterations, $#{subagent_cost.round(4)} (total: $#{@total_cost.round(4)})")
-
         # Return summary as the skill execution result
         summary
       end

data/lib/clacky/agent/skill_reflector.rb

@@ -23,17 +23,14 @@ module Clacky
 
         skill_name = @skill_execution_context[:skill_name]
 
-        @ui&.show_info("Reflecting on skill execution: #{skill_name}")
         subagent = fork_subagent
         result = subagent.run(build_skill_reflection_prompt(skill_name))
 
-        if result
-          subagent_cost = result[:total_cost_usd] || 0.0
-          @total_cost += subagent_cost
-          @ui&.update_sessionbar(cost: @total_cost, cost_source: @cost_source)
-        end
+        cost = absorb_subagent_cost(result) if result
 
         @skill_execution_context = nil
+
+        "#{skill_name} · $#{cost.round(4)}" if cost
       end
 
       private def should_reflect_on_skill?