openclacky 1.3.4 → 1.3.6

data/lib/clacky/server/session_registry.rb

@@ -44,10 +44,12 @@ module Clacky
           error:                nil,
           error_code:           nil,
           top_up_url:           nil,
+          raw_message:          nil,
           updated_at:           nil,
           agent:                nil,
           ui:                   nil,
           thread:               nil,
+          epoch:                0,
           idle_timer:           nil,
           pending_task:         nil,
           pending_working_dir:  nil
@@ -137,6 +139,40 @@ module Clacky
         end
       end
 
+      # Atomically bump the session's task epoch and return the new value.
+      # Each user message that starts a task claims a fresh epoch; a stale task
+      # thread (interrupted but not yet dead) compares its epoch against the
+      # current one and discards any side effects (status writes, broadcasts)
+      # once it has been superseded.
+      def claim_epoch(session_id)
+        @mutex.synchronize do
+          session = @sessions[session_id]
+          return nil unless session
+
+          session[:epoch] = session[:epoch].to_i + 1
+        end
+      end
+
+      # Current task epoch for a session (0 if none / unknown).
+      def current_epoch(session_id)
+        @mutex.synchronize { @sessions[session_id]&.fetch(:epoch, 0).to_i }
+      end
+
+      # Update fields only if the caller still owns the current epoch. Returns
+      # true if the update was applied, false if the epoch was stale (a newer
+      # task has taken over) or the session is gone.
+      def update_if_epoch(session_id, epoch, **fields)
+        @mutex.synchronize do
+          session = @sessions[session_id]
+          return false unless session
+          return false unless session[:epoch].to_i == epoch.to_i
+
+          fields[:updated_at] = Time.now
+          session.merge!(fields)
+          true
+        end
+      end
+
       # Return a session list from disk enriched with live registry status.
       # Sorted by created_at descending (newest first).
       #
@@ -160,7 +196,7 @@ module Clacky
       #   [ ...all_pinned_matching (newest-first), ...non_pinned (newest-first, limited) ]
       #
       # source and profile are orthogonal — either can be nil independently.
-      def list(limit: nil, before: nil, q: nil, q_scope: "name", date: nil, type: nil, include_pinned: true)
+      def list(limit: nil, before: nil, q: nil, q_scope: "name", date: nil, type: nil, exclude_type: nil, include_pinned: true)
         return [] unless @session_manager
 
         live = @mutex.synchronize do
@@ -169,7 +205,7 @@ module Clacky
             live_name  = s[:agent]&.name
             live_name  = nil if live_name&.empty?
           live_cost_source = s[:agent]&.cost_source
-          { status: s[:status], error: s[:error], error_code: s[:error_code], top_up_url: s[:top_up_url],
+          { status: s[:status], error: s[:error], error_code: s[:error_code], top_up_url: s[:top_up_url], raw_message: s[:raw_message],
             updated_at: s[:updated_at]&.iso8601,
             model: model_info&.dig(:model), model_id: model_info&.dig(:id), name: live_name,
             total_tasks: s[:agent]&.total_tasks, total_cost: s[:agent]&.total_cost,
@@ -195,6 +231,12 @@ module Clacky
           end
         end
 
+        # ── exclude_type filter ───────────────────────────────────────────────
+        if exclude_type
+          excluded = Array(exclude_type)
+          all = all.reject { |s| excluded.include?(s_source(s)) }
+        end
+
         # ── date filter (YYYY-MM-DD, matches created_at prefix) ──────────────
         all = all.select { |s| s[:created_at].to_s.start_with?(date) } if date
 
@@ -269,7 +311,7 @@ module Clacky
           model_info = s[:agent]&.current_model_info
           live_name  = s[:agent]&.name
           live_name  = nil if live_name&.empty?
-          { status: s[:status], error: s[:error], error_code: s[:error_code], top_up_url: s[:top_up_url],
+          { status: s[:status], error: s[:error], error_code: s[:error_code], top_up_url: s[:top_up_url], raw_message: s[:raw_message],
             updated_at: s[:updated_at]&.iso8601,
             model: model_info&.dig(:model), model_id: model_info&.dig(:id),
             name: live_name, total_tasks: s[:agent]&.total_tasks,
@@ -296,6 +338,7 @@ module Clacky
           error:         ls ? ls[:error] : nil,
           error_code:    ls&.dig(:error_code),
           top_up_url:    ls&.dig(:top_up_url),
+          raw_message:   ls&.dig(:raw_message),
           model:         ls&.dig(:model),
           model_id:      ls&.dig(:model_id),
           card_model:    ls&.dig(:card_model),
@@ -347,6 +390,14 @@ module Clacky
         @session_manager.all_sessions.count { |s| s_source(s) == "cron" }
       end
 
+      # Count + latest updated_at for cron sessions (used by sidebar virtual entry).
+      def cron_stats
+        return { count: 0, latest_updated_at: nil } unless @session_manager
+        cron_all = @session_manager.all_sessions.select { |s| s_source(s) == "cron" }
+        latest = cron_all.map { |s| s[:updated_at] || s[:created_at] }.compact.max
+        { count: cron_all.size, latest_updated_at: latest }
+      end
+
       # Delete a session from registry (and interrupt its thread).
       def delete(session_id)
         @mutex.synchronize do

data/lib/clacky/server/web_ui_controller.rb

@@ -230,12 +230,13 @@ module Clacky
         @broadcaster.call(@session_id, event)
       end
 
-      def show_error(message, code: nil, top_up_url: nil)
+      def show_error(message, code: nil, top_up_url: nil, raw_message: nil)
         payload = { message: message }
         payload[:code] = code if code
         payload[:top_up_url] = top_up_url if top_up_url
+        payload[:raw_message] = raw_message if raw_message
         emit("error", **payload)
-        forward_to_subscribers { |sub| sub.show_error(message, code: code, top_up_url: top_up_url) }
+        forward_to_subscribers { |sub| sub.show_error(message, code: code, top_up_url: top_up_url, raw_message: raw_message) }
       end
 
       def show_success(message)

data/lib/clacky/session_manager.rb

@@ -35,7 +35,7 @@ module Clacky
 
       # Keep only the most recent 200 sessions (best-effort, never block save)
       begin
-        cleanup_by_count(keep: 200)
+        cleanup_by_count(keep: 200, keep_cron: 200)
       rescue Exception # rubocop:disable Lint/RescueException
         # Cleanup is non-critical; swallow all errors (including AgentInterrupted)
       end
@@ -163,6 +163,33 @@ module Clacky
       chunk_path
     end
 
+    # Read the raw markdown of a chunk file. Returns nil if missing.
+    def read_chunk(chunk_path)
+      return nil unless chunk_path && File.exist?(chunk_path)
+      File.read(chunk_path)
+    end
+
+    # Split raw chunk markdown into [front_matter_hash, body_string].
+    # front_matter_hash preserves insertion order; body is everything after
+    # the closing "---". Returns [nil, raw] when there is no leading block.
+    def split_chunk_md(raw)
+      return [nil, raw.to_s] unless raw.to_s.start_with?("---")
+
+      fm_end = raw.index("\n---\n", 4)
+      return [nil, raw] unless fm_end
+
+      fm_text = raw[4...fm_end]
+      body    = raw[(fm_end + 5)..] || ""
+
+      fm = {}
+      fm_text.each_line do |line|
+        k, _, v = line.chomp.partition(":")
+        next if k.strip.empty?
+        fm[k.strip] = v.strip
+      end
+      [fm, body]
+    end
+
     # All sessions from disk, newest-first (sorted by last activity / updated_at,
     # falling back to created_at for legacy sessions without updated_at).
     # Optional filters:
@@ -305,11 +332,15 @@ module Clacky
     # are soft-deleted (moved to the session trash, recoverable). Pinned
     # sessions are never deleted and do not count toward the cap.
     # Returns count of soft-deleted sessions.
-    def cleanup_by_count(keep:)
+    def cleanup_by_count(keep:, keep_cron: 200)
       non_pinned = all_sessions.reject { |s| s[:pinned] } # already sorted newest-first
-      return 0 if non_pinned.size <= keep
 
-      victims = non_pinned[keep..]
+      cron, regular = non_pinned.partition { |s| s[:source].to_s == "cron" }
+
+      victims = []
+      victims += regular[keep..] if regular.size > keep
+      victims += cron[keep_cron..] if cron.size > keep_cron
+
       victims.each { |session| soft_delete(session[:session_id]) }
       victims.size
     end

data/lib/clacky/skill_loader.rb

@@ -441,13 +441,11 @@ module Clacky
 
     # Load default skills from gem's default_skills directory
     private def load_default_skills
-      # Get the gem's lib directory
       gem_lib_dir = File.expand_path("../", __dir__)
       default_skills_dir = File.join(gem_lib_dir, "clacky", "default_skills")
 
       return unless Dir.exist?(default_skills_dir)
 
-      # Load each skill directory
       Dir.glob(File.join(default_skills_dir, "*/SKILL.md")).each do |skill_file|
         skill_dir = File.dirname(skill_file)
         skill_name = File.basename(skill_dir)
@@ -459,6 +457,20 @@ module Clacky
           @errors << "Failed to load default skill #{skill_name}: #{e.message}"
         end
       end
+
+      # Also load skills bundled inside default_extensions/*/skills/
+      ext_skills_dir = File.join(gem_lib_dir, "clacky", "default_extensions")
+      Dir.glob(File.join(ext_skills_dir, "*/skills/*/SKILL.md")).each do |skill_file|
+        skill_dir = File.dirname(skill_file)
+        skill_name = File.basename(skill_dir)
+
+        begin
+          skill = Skill.new(Pathname.new(skill_dir))
+          register_skill(skill, source: :default)
+        rescue StandardError => e
+          @errors << "Failed to load default skill #{skill_name}: #{e.message}"
+        end
+      end
     end
   end
 end

data/lib/clacky/tools/terminal/output_cleaner.rb

@@ -35,9 +35,7 @@ module Clacky
         def clean(raw)
           return "" if raw.nil? || raw.empty?
 
-          s = raw.dup
-          s.force_encoding(Encoding::UTF_8)
-          s = s.scrub("?") unless s.valid_encoding?
+          s = Clacky::Utils::Encoding.pty_to_utf8(raw)
 
           s = s.gsub(CSI_REGEX, "")
           s = s.gsub(OSC_REGEX, "")

data/lib/clacky/tools/terminal.rb

@@ -340,10 +340,6 @@ module Clacky
           project_root: cwd || Dir.pwd
         )
 
-        # PowerShell 5 on Chinese Windows emits CP936/GBK by default; force
-        # UTF-8 so our PTY (which decodes as UTF-8) doesn't see ??? bytes.
-        safe_command = force_powershell_utf8(safe_command)
-
         # Background / dedicated path — never reuse the persistent shell,
         # because these commands stay running and would occupy the slot.
         if background
@@ -1522,45 +1518,6 @@ module Clacky
         return "" if lines.empty?
         lines.last(DISPLAY_TAIL_LINES).join("\n")
       end
-
-      # PowerShell 5 on Chinese Windows defaults [Console]::OutputEncoding
-      # to CP936/GBK; our PTY decodes as UTF-8 so non-ASCII output becomes
-      # `???`. Inject UTF-8 setup into the user's PowerShell command so the
-      # shell emits UTF-8 bytes regardless of host locale.
-      POWERSHELL_PREAMBLE =
-        "[Console]::OutputEncoding=[Text.Encoding]::UTF8;"
-
-      # Only rewrites simple `powershell[.exe]` / `pwsh[.exe]` invocations.
-      # Skips -File / -EncodedCommand / commands already handling encoding /
-      # pipelines (anything risky to splice).
-      private def force_powershell_utf8(command)
-        cmd = command.to_s
-        return command unless cmd =~ /\A\s*(?:powershell(?:\.exe)?|pwsh(?:\.exe)?)\b/i
-        return command if cmd =~ /OutputEncoding/i
-        return command if cmd =~ /\s-(?:File|EncodedCommand|enc|f)\b/i
-
-        # `-Command "..."` form: pipeline / chain characters inside the
-        # quoted body are PowerShell-internal, not shell-level, so we splice
-        # safely into the quoted string.
-        if (m = cmd.match(/\A(\s*(?:powershell(?:\.exe)?|pwsh(?:\.exe)?)\s+(?:[^"'\s]+\s+)*?-(?:Command|c)\s+)(["'])(.*)\2(\s*(?:<\s*\S+\s*)?)\z/i))
-          head, quote, body, tail = m[1], m[2], m[3], m[4].to_s
-          return "#{head}#{quote}#{POWERSHELL_PREAMBLE}#{body}#{quote}#{tail}"
-        end
-
-        # Outside the quoted-Command form, refuse to splice if there's any
-        # shell-level pipe / chain — too risky to get the boundaries right.
-        return command if cmd =~ /[|&;]/
-
-        if (m = cmd.match(/\A(\s*(?:powershell(?:\.exe)?|pwsh(?:\.exe)?))(.*)\z/i))
-          exe, rest = m[1], m[2].to_s.strip
-          return command if rest.start_with?("-") && rest !~ /\A-(?:Command|c)\b/i
-          rest = rest.sub(/\A-(?:Command|c)\b\s*/i, "")
-          inner = rest.empty? ? POWERSHELL_PREAMBLE.chomp(";") : "#{POWERSHELL_PREAMBLE}#{rest}"
-          return %Q{#{exe} -Command "#{inner}"}
-        end
-
-        command
-      end
     end
   end
 end

data/lib/clacky/ui2/components/modal_component.rb

@@ -326,7 +326,7 @@ module Clacky
               print "\e[?25l"
               return :cancelled
             when "\u0015"  # Ctrl+U - clear line
-              buffer = ''
+              buffer = String.new
               cursor_pos = 0
             else
               # Regular character input

data/lib/clacky/ui2/layout_manager.rb

@@ -120,28 +120,23 @@ module Clacky
         @render_mutex.synchronize do
           entry = @buffer.entry_by_id(id)
           if entry.nil?
-            Clacky::Logger.warn("[ph_debug] replace_entry_nil", id: id, content: content.to_s[0, 120])
             return
           end
           if entry.committed
-            Clacky::Logger.warn("[ph_debug] replace_entry_committed", id: id, content: content.to_s[0, 120])
             return
           end
           if (entry.committed_line_offset || 0) > 0
-            Clacky::Logger.warn("[ph_debug] replace_entry_partial", id: id, offset: entry.committed_line_offset, content: content.to_s[0, 120])
             return
           end
 
           old_lines = entry.lines.dup
           new_lines = wrap_content_to_lines(content)
           if old_lines == new_lines
-            Clacky::Logger.warn("[ph_debug] replace_entry_same", id: id)
             screen.flush
             return
           end
           @buffer.replace(id, new_lines)
           is_tail = @buffer.live_entries.last&.id == id
-          Clacky::Logger.warn("[ph_debug] replace_entry_paint", id: id, is_tail: is_tail, old_n: old_lines.length, new_n: new_lines.length, content: content.to_s[0, 120])
 
           unless @fullscreen_mode
             # repaint_entry_in_place relies on the entry being the tail of

data/lib/clacky/ui2/progress_handle.rb

@@ -182,7 +182,6 @@ module Clacky
       # @param final_message [String, nil] Optional override for the last
       #   frame. If nil, the handle composes "<message>… (<elapsed>s)".
       def finish(final_message: nil)
-        Clacky::Logger.warn("[ph_debug] finish_entry", oid: object_id, state: @state, unreg: @unregistered, msg: @message, eid: @entry_id)
         snapshot = @monitor.synchronize do
           return if @unregistered
           first_close = @state == :running
@@ -201,10 +200,8 @@ module Clacky
           else
             compose_final_frame(snapshot[:message], snapshot[:elapsed])
           end
-        Clacky::Logger.warn("[ph_debug] finish_unregister", oid: object_id, eid: @entry_id, first_close: snapshot[:first_close], final_frame: final_frame.to_s[0, 200])
         @owner.unregister_progress(self, final_frame: final_frame)
         @monitor.synchronize { @unregistered = true }
-        Clacky::Logger.warn("[ph_debug] finish_done", oid: object_id)
       end
       alias_method :cancel, :finish