openclacky 1.5.11 → 1.5.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1cef597eb5d6c066192ba6c2c587e0dcd62fdf2dd9ed422161f71718acbb7f25
-  data.tar.gz: 03bcd29f23eacd7b49a37db0494f7964757391ac52e8f3ef9787c49a6b2f8efb
+  metadata.gz: 858730306a6e6647d79a5ebb35160c52fba7ed26c62ec97043373e7f052332e2
+  data.tar.gz: b412bc405daae81f1b6d71dd4dd2dffc197a00ac97540ecfd4916f7daf58843d
 SHA512:
-  metadata.gz: 7543c4f518bf5a2e20778472e60909b5eda8f727015b66aad37c69b2d256b53ba3cd5126d2b385a06456a45a6531fe4fdaad7c6d7f8b247aeb2a76bf1446a9f1
-  data.tar.gz: d6ceb974a12d29096ae65bcbed3d6c6467880005101664919357572201846792faf4f89956ff5ca568519d74960674e214a39c61333e527741a9eb38083fcbf1
+  metadata.gz: 685d67556e68efd81a8bc446edd473a57939f0404b754e4432c7d29e073d2c47adc0c939fc5da3ea32144f3c6026aa17d73ff4766420399515089a3a8a4bc98d
+  data.tar.gz: dc85168d4b103185d20087635cfc5972c4e3e23b8dee95cb2ba28017d276dda425d8d92d23159dad463bd6cdcc29b8e02404d50dd4a79e5e6345193e8b4167c8

data/CHANGELOG.md

@@ -4,6 +4,40 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
+## [1.5.12] - 2026-08-27
+
+### Added
+- Add VS Code-style file tree with inline file viewer
+- Add quick-access sidebar for directory picker with WSL support
+- Add Web UI @mention references for files, directories and sessions
+- Add Gemini 3.7 Flash model with STT/video support; switch OCR default to DeepSeek vision
+- Add timestamps to assistant messages
+- Merge platform usage API data with local billing records
+- Refresh git panel on session completion
+- Allow disabling local extensions
+- Expose task mappings in core events (#496 - @YeEmrick)
+
+### Improved
+- Move file-trash sweep off the session save path and speed up session creation
+- Make recharge link a visible button on model cards
+
+### Fixed
+- Fix ask_user free-text input: render without options, guard IME composition, route Enter, render as text in IM channels, keep questions concise (#497 - @afumu)
+- Fix advisor recommendations: send structured options, keep card state per session, dismiss button no longer permanently suppresses
+- Fix home favorite pointing at the Windows profile under WSL
+- Fix session list pagination and pin truncation
+- Preserve task ids in compressed history (#500 - @YeEmrick)
+- Clear stale media model override when reverting to auto
+- Normalize gemini-3.7-flash name for pricing
+- Fix sidebar scrollbar visibility and session list styling
+- Fix messages loading created_at
+- Render parallel fan-out subagent phases as flat, isolated cards
+- Preserve subagent transcripts when an interrupted fan-out is resumed
+- Fix spinner in subagent raise process
+- Truncate messages carrying the system_injected flag
+- Stop reporting awaiting_feedback for question-mark endings
+- Detach channel_ui and keep channel_info unique on /bind and /unbind
+
 ## [1.5.11] - 2026-08-23
 
 ### Added

data/lib/clacky/agent/cost_tracker.rb

@@ -136,11 +136,13 @@ module Clacky
         # This ensures all API calls are recorded for statistics purposes.
         billing_model = model || current_model
         effective_cost = cost || 0.0  # Use 0 if pricing is unknown
+        provider = @config.provider_id_for(@config.current_model)
 
         record = Billing::BillingRecord.new(
           session_id: @session_id,
           timestamp: Time.now,
           model: billing_model,
+          provider: provider,
           prompt_tokens: usage[:prompt_tokens] || 0,
           completion_tokens: usage[:completion_tokens] || 0,
           cache_read_tokens: usage[:cache_read_input_tokens] || 0,

data/lib/clacky/agent/message_compressor_helper.rb

@@ -624,7 +624,7 @@ module Clacky
 
           case role
           when "user"
-            lines << "## User"
+            lines << (msg[:task_id] ? "## User [Task #{msg[:task_id]}]" : "## User")
             lines << ""
             lines << format_message_content(content)
             lines << ""

data/lib/clacky/agent/session_serializer.rb

@@ -391,7 +391,11 @@ module Clacky
               preview_path: f[:preview_path] || f["preview_path"] }
           }
           all_files = image_files + disk_files
-          ui.show_user_message(raw_text, created_at: msg[:created_at], files: all_files,
+          references = Array(msg[:display_references])
+          ref_options = references.empty? ? {} : { references: references }
+          task_options = msg[:task_id] ? { task_id: msg[:task_id] } : {}
+          ui.show_user_message(raw_text, **task_options, created_at: msg[:created_at], files: all_files,
+                               **ref_options,
                                editable: round[:editable] != false,
                                skill_command: msg[:skill_command],
                                skill_command_display: msg[:skill_command_display])
@@ -490,30 +494,34 @@ module Clacky
         current_role       = nil
         current_lines      = []
         current_nested_chunk = nil  # chunk reference from a Compressed Summary heading
+        current_task_id    = nil
 
         raw.each_line do |line|
           stripped = line.chomp
           if (m = stripped.match(/\A## Assistant \[Compressed Summary — original conversation at: (.+)\]/))
             # Nested chunk reference — record it, treat as assistant section
-            sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk } if current_role
+            sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk, task_id: current_task_id } if current_role
             current_role         = "assistant"
             current_lines        = []
             current_nested_chunk = File.join(chunk_dir, m[1])
-          elsif stripped.match?(/\A## (User|Assistant)/)
-            sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk } if current_role
-            current_role         = stripped.match(/\A## (User|Assistant)/)[1].downcase
+            current_task_id      = nil
+          elsif (m = stripped.match(/\A## (User|Assistant)(?: \[Task ([1-9]\d*)\])?\z/))
+            sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk, task_id: current_task_id } if current_role
+            current_role         = m[1].downcase
             current_lines        = []
             current_nested_chunk = nil
+            current_task_id      = m[2]&.to_i
           elsif stripped.match?(/\A### Tool Result:/)
-            sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk } if current_role
+            sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk, task_id: current_task_id } if current_role
             current_role         = "tool"
             current_lines        = []
             current_nested_chunk = nil
+            current_task_id      = nil
           else
             current_lines << line
           end
         end
-        sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk } if current_role
+        sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk, task_id: current_task_id } if current_role
 
         # Remove front-matter / header noise sections (nil role or non-user/assistant/tool)
         sections.select! { |s| %w[user assistant tool].include?(s[:role]) }
@@ -544,14 +552,16 @@ module Clacky
             round_index += 1
             # Synthetic timestamp: spread rounds backwards from archived_at
             synthetic_ts = base_time - (sections.size - round_index) * 1.0
+            user_msg = {
+              role: "user",
+              content: text,
+              created_at: synthetic_ts,
+              ext_events: sec_ext_events,
+              _from_chunk: true
+            }
+            user_msg[:task_id] = sec[:task_id] if sec[:task_id]
             current_round = {
-              user_msg: {
-                role: "user",
-                content: text,
-                created_at: synthetic_ts,
-                ext_events: sec_ext_events,
-                _from_chunk: true
-              },
+              user_msg: user_msg,
               events: [],
               # editable: false — this message was archived into a chunk MD and no
               # longer exists in the active in-memory @history, so it cannot be
@@ -733,7 +743,7 @@ module Clacky
             else
               raw_text
             end
-            ui.show_assistant_message(text, files: [])
+            ui.show_assistant_message(text, files: [], created_at: msg[:created_at])
           end
 
           # Tool calls embedded in assistant message
@@ -761,6 +771,11 @@ module Clacky
           # Emit token usage stored on this message (for history replay display)
           ui.show_token_usage(msg[:token_usage]) if msg[:token_usage]
 
+          # Interrupted fan-out anchors its captured subagent trails onto the
+          # last message, which is usually this assistant turn (its tool result
+          # never got written). Replay them here so they survive a reload.
+          replay_subagent_transcript(msg, ui)
+
         when "user"
           # Anthropic-format tool results (role: user, content: array of tool_result blocks)
           if msg[:content].is_a?(Array)
@@ -817,8 +832,12 @@ module Clacky
         events = transcript[:events] || transcript["events"] || []
         return if events.empty?
 
+        skill = transcript[:skill] || transcript["skill"]
+        supports_phase = ui.respond_to?(:phase_start) && ui.respond_to?(:phase_end)
+        pid = ui.phase_start(kind: "fanout_subagent", label: skill) if supports_phase
+
         ui.show_subagent_start(
-          skill:      transcript[:skill]      || transcript["skill"],
+          skill:      skill,
           iterations: transcript[:iterations] || transcript["iterations"],
           cost_usd:   transcript[:cost_usd]   || transcript["cost_usd"]
         )
@@ -831,7 +850,7 @@ module Clacky
           case role
           when "assistant"
             text = extract_text_from_content(content).to_s.strip
-            ui.show_assistant_message(text, files: []) unless text.empty?
+            ui.show_assistant_message(text, files: [], created_at: ev[:created_at] || ev["created_at"]) unless text.empty?
             Array(tool_calls).each do |tc|
               name = tc[:name] || tc["name"] || ""
               args_raw = tc[:arguments] || tc["arguments"] || {}
@@ -844,6 +863,7 @@ module Clacky
         end
 
         ui.show_subagent_end
+        ui.phase_end(pid) if supports_phase && pid
       end
 
       # Replace the system message in @messages with a freshly built system prompt.

data/lib/clacky/agent/time_machine.rb

@@ -589,6 +589,7 @@ module Clacky
 
           tasks << {
             task_id: task_id,
+            parent_task_id: @task_parents[task_id].to_i,
             summary: summary,
             started_at: meta[:started_at],
             ended_at: meta[:ended_at],

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)
 
@@ -579,10 +584,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 +605,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 +632,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 +659,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 +705,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 +835,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 +854,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 +913,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 +924,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 +932,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 +956,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 +1130,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 +1144,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 +1195,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 +1539,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 +1682,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 +1845,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 +1972,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)
 
@@ -2400,7 +2477,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 +2490,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/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") }