openclacky 1.3.5 → 1.3.7

data/lib/clacky/server/session_registry.rb

@@ -49,6 +49,7 @@ module Clacky
           agent:                nil,
           ui:                   nil,
           thread:               nil,
+          epoch:                0,
           idle_timer:           nil,
           pending_task:         nil,
           pending_working_dir:  nil
@@ -116,8 +117,15 @@ module Clacky
           src = (session_data[:source] || "manual").to_s
           next if counts[src] >= n
           next if exist?(session_data[:session_id])
-          @session_restorer.call(session_data)
-          counts[src] += 1
+          begin
+            @session_restorer.call(session_data)
+            counts[src] += 1
+          rescue => e
+            Clacky::Logger.warn(
+              "[SessionRegistry] skip session #{session_data[:session_id]}: " \
+              "#{e.class}: #{e.message}"
+            )
+          end
         end
       end
 
@@ -138,6 +146,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).
       #
@@ -161,7 +203,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
@@ -196,6 +238,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
 
@@ -349,6 +397,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/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

@@ -12,6 +12,7 @@ module Clacky
     # Skill discovery locations (in priority order: lower index = lower priority)
     LOCATIONS = [
       :default,            # gem's built-in default skills (lowest priority)
+      :extension,          # contributes.skills declared in ext.yml containers
       :global_clacky,      # ~/.clacky/skills/
       :project_clacky,     # .clacky/skills/ (highest priority among plain skills)
       :brand               # ~/.clacky/brand_skills/ (encrypted, license-gated)
@@ -62,6 +63,7 @@ module Clacky
       clear
 
       load_default_skills
+      load_extension_skills
       load_global_clacky_skills
       
       # Only load project-level skills when working_dir is explicitly provided.
@@ -401,7 +403,7 @@ module Clacky
     # @return [Skill, nil] nil when the skill was rejected (duplicate/limit)
     private def register_skill(skill, source:)
       id             = skill.identifier
-      priority_order = %i[default global_clacky project_clacky brand]
+      priority_order = %i[default extension global_clacky project_clacky brand]
 
       # --- duplicate check ---
       if (existing = @skills[id])
@@ -472,5 +474,30 @@ module Clacky
         end
       end
     end
+
+    # Load skills declared via `contributes.skills` in ext.yml containers.
+    # Protected (encrypted) units are skipped here — they are listed by
+    # ExtensionLoader for display/management but their decryption still flows
+    # through the legacy brand_skill chain (see load_brand_skills).
+    private def load_extension_skills
+      result = Clacky::ExtensionLoader.last_result
+      return unless result&.skills
+
+      result.skills.each do |unit|
+        next if unit.spec["protected"] || unit.spec["encrypted"]
+
+        skill_dir_abs = unit.spec["skill_dir_abs"]
+        next unless File.directory?(skill_dir_abs) && File.file?(File.join(skill_dir_abs, "SKILL.md"))
+
+        begin
+          skill = Skill.new(Pathname.new(skill_dir_abs))
+          register_skill(skill, source: :extension)
+        rescue Clacky::AgentError => e
+          @errors << "Error loading extension skill '#{unit.id}' from #{skill_dir_abs}: #{e.message}"
+        rescue StandardError => e
+          @errors << "Unexpected error loading extension skill '#{unit.id}' from #{skill_dir_abs}: #{e.message}"
+        end
+      end
+    end
   end
 end

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
 

data/lib/clacky/ui2/ui_controller.rb

@@ -664,22 +664,13 @@ module Clacky
 
       # Called by ProgressHandle#finish.
       def unregister_progress(handle, final_frame:)
-        Clacky::Logger.warn("[ph_debug] unreg_entry", oid: handle.object_id, eid: handle.entry_id, top: @progress_stack.last == handle, stack_size: @progress_stack.size, ff: final_frame.to_s[0, 200])
         @progress_mutex.synchronize do
-          # If this handle still holds its entry (it's currently top), we
-          # render one last frame there and release the id. If it was
-          # previously detached (someone above is still active), its entry
-          # is already gone and the final_frame is simply dropped.
           if handle.entry_id
             if final_frame && !final_frame.to_s.strip.empty?
-              Clacky::Logger.warn("[ph_debug] unreg_update_entry", oid: handle.object_id, eid: handle.entry_id)
               update_entry(handle.entry_id, @renderer.render_progress(final_frame))
             else
-              Clacky::Logger.warn("[ph_debug] unreg_remove_entry", oid: handle.object_id, eid: handle.entry_id)
               remove_entry(handle.entry_id)
             end
-          else
-            Clacky::Logger.warn("[ph_debug] unreg_no_entry_id", oid: handle.object_id)
           end
 
           @progress_stack.delete(handle)
@@ -1094,12 +1085,15 @@ module Clacky
           queue.push(:timeout) unless session[:intervened]
         end
 
-        result = queue.pop
-        session[:watchdog].kill if session[:watchdog]&.alive?
-        @feedback_countdown = nil
-        @layout.remove_entry(entry_id) if entry_id
-        @layout.recalculate_layout
-        @layout.render_all
+        begin
+          result = queue.pop
+        ensure
+          session[:watchdog].kill if session[:watchdog]&.alive?
+          @feedback_countdown = nil
+          @layout.remove_entry(entry_id) if entry_id
+          @layout.recalculate_layout
+          @layout.render_all
+        end
 
         if result == :timeout
           append_output(theme.format_text("  No response — continuing automatically.", :thinking))

data/lib/clacky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clacky
-  VERSION = "1.3.5"
+  VERSION = "1.3.7"
 end