openclacky 1.5.5 → 1.5.7

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
@@ -33,6 +34,12 @@ module Clacky
         # Restore project association (nil = no project)
         @project_id = session_data[:project_id]
 
+        # Restore standing goal state (nil = no goal). The judge client/model
+        # are rebound lazily via #goal_manager when first accessed after
+        # restore — but the persisted state must be reattached here so a
+        # restored active goal keeps its progress and continues.
+        restore_goal_state(session_data[:goal])
+
         # Restore cache statistics if available
         @cache_stats = session_data.dig(:stats, :cache_stats) || {
           cache_creation_input_tokens: 0,
@@ -120,6 +127,22 @@ module Clacky
         refresh_system_prompt
       end
 
+      # Reattach persisted goal state after a restore. Builds a fresh
+      # GoalManager (bound to this agent's judge client/model) and injects the
+      # deserialized GoalState so a restored active goal keeps its progress.
+      private def restore_goal_state(goal_data)
+        return if goal_data.nil? || goal_data.empty?
+
+        state = GoalState.from_h(goal_data)
+        @goal_manager = GoalManager.new(
+          judge_client: @client,
+          judge_model:  judge_model_name,
+          state:        state
+        )
+      rescue => e
+        Clacky::Logger.warn("restore_goal_state failed: #{e.message}")
+      end
+
       # Fill missing entries in @task_meta from @history (for sessions saved
       # before task_meta existed, or for tasks whose meta was lost). The first
       # real user message of each task supplies the title; created_at becomes
@@ -168,7 +191,7 @@ module Clacky
         latest_path = chunks.last[:path]
         broken.each { |m| m[:chunk_path] = latest_path }
 
-        session_manager.save(to_session_data(preserve_updated_at: true))
+        session_manager.save(to_session_data)
       rescue => e
         Clacky::Logger.warn("heal_missing_chunk_paths! failed: #{e.message}")
       end
@@ -183,7 +206,7 @@ module Clacky
       # @param status [Symbol] Status of the last task: :success, :error, or :interrupted
       # @param error_message [String] Error message if status is :error
       # @return [Hash] Session data ready for serialization
-      def to_session_data(status: :success, error_message: nil, raw_message: nil, updated_at: nil, preserve_updated_at: false)
+      def to_session_data(status: :success, error_message: nil, raw_message: nil, updated_at: nil)
         stats_data = {
           total_tasks: @total_tasks,
           total_iterations: @iterations,
@@ -204,9 +227,8 @@ module Clacky
           session_id: @session_id,
           name: @name,
           pinned: @pinned,
-          hidden: @hidden,
           created_at: @created_at,
-          updated_at: (updated_at || (preserve_updated_at && @persisted_updated_at) || Time.now.iso8601).then { |v| v.is_a?(String) ? v : v.iso8601 },
+          updated_at: (updated_at || @persisted_updated_at || Time.now.iso8601).then { |v| v.is_a?(String) ? v : v.iso8601 },
           working_dir: @working_dir,
           source: @source.to_s,                      # "manual" | "cron" | "channel" | "setup"
           agent_profile: @agent_profile&.name || "", # "general" | "coding" | custom
@@ -241,6 +263,7 @@ module Clacky
           },
           channel_info: @channel_info,
           project_id:   @project_id,
+          goal:         @goal_manager&.to_h,
           stats: stats_data,
           messages: @history.to_a
         }
@@ -370,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)
@@ -499,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]
@@ -511,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
@@ -522,6 +547,7 @@ module Clacky
                 role: "user",
                 content: text,
                 created_at: synthetic_ts,
+                ext_events: sec_ext_events,
                 _from_chunk: true
               },
               events: [],
@@ -546,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
@@ -576,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
@@ -589,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)
@@ -641,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)
+          if msg[:content].is_a?(Array)
+            msg[:content].each do |blk|
+              next unless blk.is_a?(Hash) && blk[:type] == "tool_result"
 
-          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?