openclacky 1.5.11 → 1.5.13

data/lib/clacky/agent.rb

@@ -113,6 +113,7 @@ module Clacky
       @pending_script_tmpdirs = [] # Decrypted-script tmpdirs that live for the agent's lifetime
       @pending_error_rollback = false  # Deferred rollback flag set by restore_session on error
       @last_run_interrupted = false    # Set when run() exits via AgentInterrupted; tells the next run() to keep the task-start snapshot (continuation of the same task across a relay, not a brand-new task)
+      @cancel_flag = CancelFlag.new # Cooperative cancel: set by fan_out_labeled when the parent is interrupted; subagents on worker threads observe it via check_stale!
 
       # Compression tracking
       @compression_level = 0  # Tracks how many times we've compressed (for progressive summarization)
@@ -473,7 +474,7 @@ module Clacky
       @name = new_name.to_s.strip
     end
 
-    def run(user_input, files: [], display_text: nil, created_at: nil)
+    def run(user_input, files: nil, reference_contexts: nil, display_text: nil, created_at: nil, references_display: nil)
       # Intercept /goal ... commands before any task/LLM work. Control-plane
       # commands (status/pause/resume/clear) return immediately without a turn;
       # `/goal <text>` sets the goal, then falls through to run the first turn.
@@ -497,6 +498,10 @@ module Clacky
       # idempotent update on the same progress UI element.
       @ui&.show_progress
 
+      # A reused agent may carry a cancel flag set by a previously-interrupted
+      # fan-out batch; a fresh task must start uncancelled.
+      @cancel_flag = CancelFlag.new
+
       # Start new task for Time Machine
       task_id = start_new_task(title: display_text.to_s.empty? ? user_input.to_s : display_text.to_s)
 
@@ -563,9 +568,12 @@ module Clacky
       all_disk_files = disk_files + downgraded
 
       # Format user message — text + inline vision images
-      # Store the tmp path alongside the data_url so the history replay can
-      # reconstruct the image if the base64 was stripped (e.g. after compression).
-      user_content = format_user_content(user_input, vision_images.map { |v| { url: v[:url], path: v[:path] } })
+      # Store the tmp path and original name alongside the data_url: the path supports
+      # normal replay, while the name becomes the lightweight badge after compression.
+      user_content = format_user_content(
+        user_input,
+        vision_images.map { |v| { url: v[:url], path: v[:path], name: v[:name] } }
+      )
 
       # Parse disk files — agent's responsibility, not the upload layer.
       # process_path runs the parser script and returns a FileRef with preview_path or parse_error.
@@ -579,10 +587,19 @@ module Clacky
         # "too large" note for downgraded images.
         downgrade_reason = f[:downgrade_reason] || f["downgrade_reason"]
         ocr_text         = f[:ocr_text]         || f["ocr_text"]
+        reference        = f[:reference]        || f["reference"]
+
+        # Directory references: capture only the path so the LLM can explore
+        # on demand with the read/shell tools.
+        if File.directory?(path.to_s)
+          next { name: name || File.basename(path.to_s), type: "directory", path: path.to_s,
+                 reference: reference }
+        end
+
         ref = Utils::FileProcessor.process_path(path, name: name)
         { name: ref.name, type: ref.type.to_s, path: ref.original_path,
           preview_path: ref.preview_path, parse_error: ref.parse_error, parser_path: ref.parser_path,
-          downgrade_reason: downgrade_reason, ocr_text: ocr_text }
+          downgrade_reason: downgrade_reason, ocr_text: ocr_text, reference: reference }
       end
 
       # Build display_files for replay: lightweight metadata so the UI can reconstruct
@@ -591,6 +608,10 @@ module Clacky
       # images (provider has no vision / too large / OCR'd) DO need path here so the
       # UI can re-render them from the on-disk copy across session switches.
       display_files = all_disk_files.filter_map do |f|
+        # @mention file/directory references are replayed from display_references
+        # (with mention badges), so skip them here to avoid double-rendering as
+        # plain attachment badges.
+        next if f[:reference] || f["reference"]
         name = f[:name] || f["name"]
         next unless name
         { name: name, type: f[:type] || f["type"] || "file",
@@ -614,7 +635,8 @@ module Clacky
                         display_text: display_text,
                         skill_command: skill_command[:found] ? skill_command[:skill_name] : nil,
                         skill_command_display: skill_command_display,
-                        display_files: display_files.empty? ? nil : display_files })
+                        display_files: display_files.empty? ? nil : display_files,
+                        display_references: Array(references_display).empty? ? nil : references_display })
       @total_tasks += 1
 
       # Inject disk file references as a system_injected message so:
@@ -640,6 +662,12 @@ module Clacky
 
           next unless name
 
+          # Directory reference: emit only the path so the LLM can explore on
+          # demand with the read/shell tools.
+          if type == "directory"
+            next ["[Directory: #{name}]", "Path: #{path}"].join("\n")
+          end
+
           lines = ["[File: #{name}]", "Type: #{type || "file"}"]
           lines << "Size: #{format_size(size_bytes)}" if size_bytes
           lines << "Original: #{path}" if path
@@ -680,17 +708,32 @@ module Clacky
         end
       end
 
-      # If the user typed a slash command targeting a skill with disable-model-invocation: true,
-      # inject the skill content as a synthetic assistant message so the LLM can act on it.
-      # Skills already in the system prompt (model_invocation_allowed?) are skipped.
-      inject_skill_command_as_assistant_message(skill_command, task_id)
-
-      @hooks.trigger(:on_start, user_input)
+      # Inject referenced past chats (the @mention "send as reference" behavior)
+      # as a system_injected message — same mechanism as file references: the LLM
+      # sees the context, but replay_history skips it and no user bubble renders.
+      Array(reference_contexts).each do |ctx|
+        next if ctx.to_s.strip.empty?
+        @history.append({ role: "user", content: ctx, system_injected: true, task_id: task_id })
+      end
 
       result = nil
       begin
+        # If the user typed a slash command targeting a skill with disable-model-invocation: true,
+        # inject the skill content as a synthetic assistant message so the LLM can act on it.
+        # Skills already in the system prompt (model_invocation_allowed?) are skipped.
+        # Inside the begin block so a fork_subagent failure (e.g. skill-declared model
+        # not found) still reaches the ensure block that stops the progress spinner.
+        inject_skill_command_as_assistant_message(skill_command, task_id)
+
+        @hooks.trigger(:on_start, user_input)
+
         # Track if ask_user was called
         awaiting_user_feedback = false
+        # Heuristic sibling of the above: the reply merely ended with a question
+        # mark. Kept separate because it must never reach build_result — the
+        # session status it feeds shows a "waiting" badge to the user, and a
+        # rhetorical closing question is not a request for input.
+        turn_unfinished = false
         # Track if task was interrupted by user (denied tool execution)
         task_interrupted = false
 
@@ -795,7 +838,7 @@ module Clacky
               )
             end
             if response[:content] && !response[:content].empty?
-              emit_assistant_message(response[:content], reasoning_content: response[:reasoning_content])
+              emit_assistant_message(response[:content], reasoning_content: response[:reasoning_content], created_at: response[:created_at])
             end
 
             # Show token usage after the assistant message so WebUI renders it below the bubble
@@ -814,14 +857,14 @@ module Clacky
             # If the assistant ended its turn with a question, treat this as
             # an in-flight conversation (agent is awaiting the user's reply)
             # and skip skill evolution — the task isn't truly complete yet.
-            awaiting_user_feedback = true if ends_with_question
+            turn_unfinished = true if ends_with_question
 
             break
           end
 
           # Show assistant message if there's content before tool calls
           if response[:content] && !response[:content].empty?
-            emit_assistant_message(response[:content], reasoning_content: response[:reasoning_content], interim: true)
+            emit_assistant_message(response[:content], reasoning_content: response[:reasoning_content], interim: true, created_at: response[:created_at])
           end
 
           # Show token usage after assistant message (or immediately if no message).
@@ -873,7 +916,7 @@ module Clacky
         # Run skill evolution hooks after main loop completes
         # Skip if task was interrupted by user (denied tool) or awaiting user feedback
         # Only for main agent (not subagents) to avoid recursive evolution
-        unless @is_subagent || task_interrupted || awaiting_user_feedback
+        unless @is_subagent || task_interrupted || awaiting_user_feedback || turn_unfinished
           run_skill_evolution_hooks
         end
 
@@ -884,7 +927,7 @@ module Clacky
         # and only then [OK] Task Complete is printed. No cleanup dance,
         # no cross-method progress handle holding.
         # Skip on interrupt / feedback / subagent (self-guarded inside too).
-        unless @is_subagent || task_interrupted || awaiting_user_feedback
+        unless @is_subagent || task_interrupted || awaiting_user_feedback || turn_unfinished
           run_memory_update_subagent
         end
 
@@ -892,6 +935,7 @@ module Clacky
           # Parent agent (skill_manager) prints the completion summary; skip here.
         else
           @ui&.show_complete(
+            task_id: result[:task_id],
             iterations: result[:iterations],
             cost: result[:total_cost_usd],
             cost_source: result[:cost_source],
@@ -915,6 +959,10 @@ module Clacky
 
         result
       rescue Clacky::AgentInterrupted
+        # A cancelled fan-out captured its subagents' progress but never reached
+        # observe() to persist it — anchor those trails now so a page reload
+        # after the interrupt still shows what the subagents did.
+        flush_pending_subagent_transcripts_on_interrupt
         # Mark this run as interrupted so the next run() (e.g. user's
         # supplementary message during a running task) keeps the existing
         # task-start snapshot — the completion summary should reflect the
@@ -1085,7 +1133,8 @@ module Clacky
                    "- Break down large tasks into multiple smaller tool calls\n" \
                    "- Keep each tool call argument under 2000 characters\n" \
                    "- Use multiple tool calls instead of one large call",
-          truncated: true
+          truncated: true,
+          system_injected: true
         })
 
         # Close the current spinner so the warning appears cleanly;
@@ -1098,7 +1147,11 @@ module Clacky
       end
 
       # Add assistant response to history
-      msg = { role: "assistant", task_id: @current_task_id }
+      created_at = Time.now.to_f
+      msg = { role: "assistant", task_id: @current_task_id, created_at: created_at }
+      # Surface the storage timestamp to the caller so the live UI emit uses
+      # the same created_at that replay will later read back from history.
+      response[:created_at] = created_at
       # Always include content field (some APIs require it even with tool_calls)
       # Use empty string instead of null for better compatibility
       msg[:content] = response[:content] || ""
@@ -1145,6 +1198,7 @@ module Clacky
     # to history — guarantees a stale thread cannot corrupt history with
     # tool messages that no longer have a matching assistant tool_calls.
     private def check_stale!
+      raise Clacky::AgentInterrupted, "Fan-out batch cancelled by a newer task" if @cancel_flag&.cancelled?
       return unless @task_thread
       return if Thread.current == @task_thread
       raise Clacky::AgentInterrupted, "Task superseded by a newer task on another thread"
@@ -1488,6 +1542,26 @@ module Clacky
       end
     end
 
+    # Interrupt-path counterpart to attach_pending_subagent_transcripts: a
+    # cancelled fan-out never reaches observe(), so its captured job trails
+    # would otherwise die in @pending_subagent_transcripts (memory only) and
+    # vanish on the next page reload. Anchor whatever was captured onto the
+    # last history message so it persists to session.json and replays.
+    private def flush_pending_subagent_transcripts_on_interrupt
+      pending = @subagent_transcripts_mutex.synchronize do
+        snapshot = @pending_subagent_transcripts.dup
+        @pending_subagent_transcripts.clear
+        snapshot
+      end
+      return if pending.empty?
+
+      by_id = {}
+      pending.each { |id, trails| by_id[id] = Array(trails).sort_by { |t| t[:index] || 0 } }
+      @history.settle_interrupted_tool_calls(by_id)
+    rescue StandardError => e
+      Clacky::Logger.warn("agent.flush_subagent_transcripts_failed", error: e.message)
+    end
+
     # Cap oversized tool result content to keep a single tool message from
     # blowing up the prompt budget (issue #218: a 7350-path glob produced a
     # ~890k-char result that pushed history past the model context window
@@ -1611,6 +1685,7 @@ module Clacky
       {
         status: status,
         session_id: @session_id,
+        task_id: @current_task_id,
         model: current_model,
         provider: current_provider,
         iterations: task_iterations,
@@ -1773,7 +1848,8 @@ module Clacky
         end
       end
 
-      Fanout.new(max_concurrency: max_concurrency, timeout: timeout).run(wrapped)
+      Fanout.new(max_concurrency: max_concurrency, timeout: timeout)
+            .run(wrapped, on_cancel: -> { @cancel_flag&.cancel! })
     end
 
     private def within_phase(label, kind:, concurrent:, &block)
@@ -1899,6 +1975,10 @@ module Clacky
       )
       subagent.instance_variable_set(:@is_subagent, true)
 
+      # Share the parent's cancel flag so a fan-out interrupt reaches this
+      # subagent on its worker thread — its own check_stale! polls the same flag.
+      subagent.instance_variable_set(:@cancel_flag, @cancel_flag)
+
       # Inherit previous_total_tokens so the first iteration delta is calculated correctly
       subagent.instance_variable_set(:@previous_total_tokens, @previous_total_tokens)
 
@@ -2274,10 +2354,10 @@ module Clacky
 
     # Build user message content for LLM.
     # Returns plain String when no vision images; Array of content parts otherwise.
-    # Build user message content for LLM.
-    # vision_images: Array of String (plain url) OR Hash { url:, path: }
-    # path is stored in the block so history replay can reconstruct the image
-    # from the tmp file when the base64 data_url is no longer available.
+    # vision_images: Array of String (plain url) OR Hash { url:, path:, name: }
+    # path is stored so normal history replay can reconstruct the image; name is
+    # lightweight metadata used for an archived badge after compression. Both
+    # fields are stripped by MessageHistory before the content reaches the API.
     private def format_user_content(text, vision_images)
       vision_images ||= []
 
@@ -2289,6 +2369,7 @@ module Clacky
         if img.is_a?(Hash)
           block = { type: "image_url", image_url: { url: img[:url] } }
           block[:image_path] = img[:path] if img[:path]
+          block[:image_name] = img[:name] if img[:name]
           content << block
         else
           content << { type: "image_url", image_url: { url: img } }
@@ -2400,7 +2481,7 @@ module Clacky
     # and cannot load file:// directly) and must stay scoped to the Web UI
     # controller. IM channel subscribers need the original file:// markdown so
     # parse_file_links can extract paths and deliver images as native attachments.
-    private def emit_assistant_message(content, reasoning_content: nil, interim: false)
+    private def emit_assistant_message(content, reasoning_content: nil, interim: false, created_at: nil)
       # Prepend reasoning/thinking content (from thinking-mode providers like
       # DeepSeek V4, Kimi K2) wrapped in <think> tags so the Web UI renders it
       # as a collapsible thinking block (see sessions.js _renderMarkdown).
@@ -2413,7 +2494,7 @@ module Clacky
       return if full_content.nil? || full_content.to_s.strip.empty?
 
       parsed = parse_file_links(content)
-      @ui&.show_assistant_message(full_content, files: parsed[:files], interim: interim)
+      @ui&.show_assistant_message(full_content, files: parsed[:files], interim: interim, created_at: created_at)
     end
 
     # Record BEFORE-change snapshots for any file a tool is about to mutate,

data/lib/clacky/agent_config.rb

@@ -402,6 +402,46 @@ module Clacky
       Clacky::ProxyConfig.reset_cache! if defined?(Clacky::ProxyConfig)
     end
 
+    # Re-read config.yml from disk and apply it to this instance in place.
+    #
+    # Two invariants make this safe for a running server:
+    #   1. @models is mutated with #replace, never reassigned — every session
+    #      built via #deep_copy shares that array by design (see #deep_copy).
+    #   2. Model ids are regenerated on every load and are not persisted, so
+    #      fresh entries inherit the id of the matching old entry (same model
+    #      name + base_url). Otherwise every session's @current_model_id
+    #      would dangle after a reload.
+    #
+    # Returns true when applied, false when the file could not be parsed —
+    # in-memory config is left untouched rather than wiped.
+    def reload!(config_file = CONFIG_FILE)
+      fresh = self.class.load(config_file)
+
+      fresh.models.each do |m|
+        previous = find_model_by_name_and_url(m["model"], m["base_url"])
+        m["id"] = previous["id"] if previous
+      end
+
+      @models.replace(fresh.models)
+
+      CONFIG_SETTINGS_KEYS.each do |key|
+        send("#{key}=", fresh.send(key))
+      end
+
+      # A session may have been pinned to a model the user just deleted.
+      unless @models.any? { |m| m["id"] == @current_model_id }
+        fallback = find_model_by_type("default") || @models.first
+        @current_model_id    = fallback && fallback["id"]
+        @current_model_index = fallback ? @models.index(fallback).to_i : 0
+      end
+
+      Clacky::ProxyConfig.reset_cache! if defined?(Clacky::ProxyConfig)
+      true
+    rescue StandardError => e
+      Clacky::Logger.warn("[AgentConfig] reload! failed: #{e.class}: #{e.message}") if defined?(Clacky::Logger)
+      false
+    end
+
     # Convert to YAML format (top-level array)
     # Auto-injected lite models (auto_injected: true) are excluded from persistence —
     # they are regenerated at load time from the provider preset.

data/lib/clacky/agent_profile.rb

@@ -88,11 +88,11 @@ module Clacky
     # @param recency [Hash<String, Integer>] agent id => epoch of last use,
     #   used to order third-party extension agents by most-recently-used
     #   instead of their static `order` field.
-    # @return [Array<Hash>] each: { id:, title:, title_zh:, description:, description_zh:, source:, order:, layer:, author:, avatar: }
+    # @return [Array<Hash>] each: { id:, title:, title_zh:, description:, description_zh:, source:, order:, layer:, author:, avatar:, hidden: }
     def self.all(recency: {})
       out = {}
 
-      add = lambda do |id, title, title_zh, description, description_zh, source, order, layer, author, avatar|
+      add = lambda do |id, title, title_zh, description, description_zh, source, order, layer, author, avatar, hidden|
         next if id.nil? || id.empty?
         out[id] = {
           id: id,
@@ -105,13 +105,13 @@ module Clacky
           layer: layer,
           author: author,
           avatar: avatar,
+          hidden: hidden,
         }
       end
 
       ext_result = ExtensionLoader.last_result || ExtensionLoader.load_all
       ext_result&.agents&.each do |unit|
         spec = unit.spec || {}
-        next if spec["hidden"]
         title = spec["title"].to_s
         title = unit.id if title.empty?
         avatar = spec["avatar_abs"].to_s.empty? ? nil : "/agent_avatar/#{unit.id}"
@@ -119,7 +119,7 @@ module Clacky
           unit.id, title, spec["title_zh"].to_s,
           spec["description"].to_s, spec["description_zh"].to_s,
           "extension", spec["order"], unit.layer.to_s,
-          spec["author"].to_s, avatar
+          spec["author"].to_s, avatar, !!spec["hidden"]
         )
       end
 
@@ -134,7 +134,7 @@ module Clacky
           id, meta["title"] || meta["name"] || id, meta["title_zh"].to_s,
           meta["description"].to_s, meta["description_zh"].to_s,
           "user", meta["order"], "user",
-          meta["author"].to_s.empty? ? "You" : meta["author"].to_s, user_avatar
+          meta["author"].to_s.empty? ? "You" : meta["author"].to_s, user_avatar, false
         )
       end
 

data/lib/clacky/billing/billing_record.rb

@@ -9,6 +9,7 @@ module Clacky
       :session_id,            # Associated session ID
       :timestamp,             # Time of the API call
       :model,                 # Model used (e.g., "claude-sonnet-4.5")
+      :provider,              # Provider id (e.g., "openclacky", "anthropic")
       :prompt_tokens,         # Input tokens
       :completion_tokens,     # Output tokens
       :cache_read_tokens,     # Tokens read from cache
@@ -24,6 +25,7 @@ module Clacky
           session_id: session_id,
           timestamp: timestamp.is_a?(Time) ? timestamp.iso8601 : timestamp,
           model: model,
+          provider: provider,
           prompt_tokens: prompt_tokens || 0,
           completion_tokens: completion_tokens || 0,
           cache_read_tokens: cache_read_tokens || 0,
@@ -40,6 +42,7 @@ module Clacky
           session_id: hash[:session_id] || hash["session_id"],
           timestamp: parse_timestamp(hash[:timestamp] || hash["timestamp"]),
           model: hash[:model] || hash["model"],
+          provider: hash[:provider] || hash["provider"],
           prompt_tokens: hash[:prompt_tokens] || hash["prompt_tokens"] || 0,
           completion_tokens: hash[:completion_tokens] || hash["completion_tokens"] || 0,
           cache_read_tokens: hash[:cache_read_tokens] || hash["cache_read_tokens"] || 0,

data/lib/clacky/billing/billing_store.rb

@@ -5,6 +5,7 @@ require "fileutils"
 require "securerandom"
 require_relative "billing_record"
 require_relative "../session_manager"
+require_relative "../providers"
 module Clacky
   module Billing
     # Persistent storage for billing records using JSONL files
@@ -12,6 +13,27 @@ module Clacky
     class BillingStore
       BILLING_DIR = File.join(Dir.home, ".clacky", "billing")
 
+      # Preset keys that hold the openclacky model lineup (chat + media sidecars).
+      OPENCLACKY_MODEL_KINDS = %w[models image_models video_models audio_models stt_models video_understanding_models].freeze
+
+      # All openclacky model aliases, collected from the provider preset so the
+      # list never drifts from providers.rb as models are added or removed.
+      def openclacky_models
+        @openclacky_models ||= begin
+          preset = Clacky::Providers.get("openclacky")
+          return [] unless preset
+          OPENCLACKY_MODEL_KINDS.flat_map { |kind| preset[kind] || [] }.uniq
+        end
+      end
+
+      # True when a record belongs to the openclacky provider. New records
+      # carry an explicit provider id; legacy records (written before the
+      # field existed) are detected by matching the full openclacky model list.
+      def openclacky_record?(record)
+        return true if record.provider == "openclacky"
+        openclacky_models.include?(record.model.to_s)
+      end
+
       def initialize(billing_dir: nil)
         @billing_dir = billing_dir || ENV["CLACKY_BILLING_DIR"] || BILLING_DIR
         ensure_billing_dir
@@ -38,9 +60,10 @@ module Clacky
       # @param to [Time, nil] End time (inclusive)
       # @param model [String, nil] Filter by model name
       # @param session_id [String, nil] Filter by session ID
+      # @param exclude_openclacky [Boolean] Skip openclacky-provider records
       # @param limit [Integer, nil] Maximum number of records to return
       # @return [Array<BillingRecord>] Matching records, newest first
-      def query(from: nil, to: nil, model: nil, session_id: nil, limit: nil)
+      def query(from: nil, to: nil, model: nil, session_id: nil, exclude_openclacky: false, limit: nil)
         records = []
 
         billing_files.each do |file|
@@ -56,6 +79,7 @@ module Clacky
               next if to && record.timestamp > to
               next if model && record.model != model
               next if session_id && record.session_id != session_id
+              next if exclude_openclacky && openclacky_record?(record)
 
               records << record
             rescue JSON::ParserError
@@ -75,10 +99,11 @@ module Clacky
       # Get summary statistics for a time period
       # @param period [Symbol] :day, :week, :month, :year, or :all
       # @param model [String, nil] Filter by model name
+      # @param exclude_openclacky [Boolean] Skip openclacky-provider records
       # @return [Hash] Summary with total_cost, total_tokens, by_model, etc.
-      def summary(period: :month, model: nil)
+      def summary(period: :month, model: nil, exclude_openclacky: false)
         from_time = period_start(period)
-        records = query(from: from_time, model: model)
+        records = query(from: from_time, model: model, exclude_openclacky: exclude_openclacky)
 
         total_cost = records.sum { |r| r.cost_usd || 0 }
         total_prompt = records.sum { |r| r.prompt_tokens || 0 }
@@ -222,10 +247,11 @@ module Clacky
 
       # Get daily cost breakdown for the last N days      # @param days [Integer] Number of days to include
       # @param model [String, nil] Filter by model name
+      # @param exclude_openclacky [Boolean] Skip openclacky-provider records
       # @return [Array<Hash>] Daily summaries with date and cost
-      def daily_breakdown(days: 30, model: nil)
+      def daily_breakdown(days: 30, model: nil, exclude_openclacky: false)
         from_time = Time.now - (days * 24 * 60 * 60)
-        records = query(from: from_time, model: model)
+        records = query(from: from_time, model: model, exclude_openclacky: exclude_openclacky)
 
         by_day = records.group_by { |r| r.timestamp.strftime("%Y-%m-%d") }