openclacky 1.1.6 → 1.2.0

data/lib/clacky/server/server_master.rb

@@ -26,9 +26,6 @@ module Clacky
       RESTART_EXIT_CODE        = 75
       MAX_CONSECUTIVE_FAILURES = 5
 
-      # How long (seconds) to wait for a new worker to become ready before killing the old one.
-      NEW_WORKER_BOOT_WAIT = 3
-
       def initialize(host:, port:, argv: nil, extra_flags: [])
         @host   = host
         @port   = port
@@ -158,22 +155,16 @@ module Clacky
         pid
       end
 
-      # Spawn a new worker, wait for it to boot, then gracefully stop the old one.
+      # Gracefully stop the old worker (so it can persist in-memory sessions),
+      # wait for it to exit, then spawn a new one.
       def hot_restart
         old_pid = @worker_pid
-        Clacky::Logger.info("[Master] Hot restart: spawning new worker (old PID=#{old_pid})...")
-
-        new_pid = spawn_worker
-        @worker_pid = new_pid
+        Clacky::Logger.info("[Master] Hot restart: stopping old worker PID=#{old_pid}...")
 
-        # Give the new worker time to bind and start serving
-        sleep NEW_WORKER_BOOT_WAIT
-
-        # Gracefully stop old worker — TERM the whole process group first so
-        # grandchildren (node MCP, etc.) also get a chance to shut down cleanly.
+        # TERM the old worker's process group so grandchildren (node MCP, etc.)
+        # also get a chance to shut down cleanly (triggering interrupt_all_agents).
         begin
           Process.kill("TERM", -old_pid)
-          # Reap it (non-blocking loop so we don't block the monitor)
           deadline = Time.now + 5
           loop do
             pid, = Process.waitpid2(old_pid, Process::WNOHANG)
@@ -186,6 +177,9 @@ module Clacky
           # already gone — fine
         end
 
+        # Old worker is gone; now spawn the replacement.
+        new_pid = spawn_worker
+        @worker_pid = new_pid
         Clacky::Logger.info("[Master] Hot restart complete. New worker PID=#{new_pid}")
       end
 

data/lib/clacky/server/session_registry.rb

@@ -166,7 +166,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], model: model_info&.dig(:model), name: live_name,
+          { status: s[:status], error: s[:error], 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,
             cost_source: live_cost_source,
             reasoning_effort: s[:agent]&.reasoning_effort,
@@ -239,7 +239,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], model: model_info&.dig(:model),
+          { status: s[:status], error: s[:error], 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, cost_source: s[:agent]&.cost_source,
             reasoning_effort: s[:agent]&.reasoning_effort,
@@ -260,6 +260,7 @@ module Clacky
           status:        ls ? ls[:status].to_s : "idle",
           error:         ls ? ls[:error] : nil,
           model:         ls&.dig(:model),
+          model_id:      ls&.dig(:model_id),
           source:        s_source(s),
           agent_profile: (s[:agent_profile] || "general").to_s,
           working_dir:   s[:working_dir],
@@ -366,6 +367,27 @@ module Clacky
         to_evict.each { |id, session| persist_and_release(id, session) }
       end
 
+      # Yield [session_id, agent, thread] for each session that currently has
+      # an in-memory agent. Used by the worker's graceful-shutdown path to
+      # flush any unsaved @history (e.g. a user message added at the start
+      # of Agent#run that hasn't yet reached the save-on-completion branch
+      # in run_agent_task).
+      #
+      # The session id list is snapshotted under the mutex so concurrent
+      # mutations don't disturb iteration; the yield happens outside the
+      # mutex so callers can do slow I/O (JSON serialization, File.write)
+      # without blocking other registry operations.
+      def each_live_agent
+        snapshot = @mutex.synchronize do
+          @sessions.filter_map do |id, s|
+            agent = s[:agent]
+            next nil unless agent
+            [id, agent, s[:thread]]
+          end
+        end
+        snapshot.each { |id, agent, thread| yield id, agent, thread }
+      end
+
       private def persist_and_release(id, session)
         agent = session[:agent]
         @session_manager&.save(agent.to_session_data(status: :success)) if agent

data/lib/clacky/server/web_ui_controller.rb

@@ -97,6 +97,10 @@ module Clacky
         forward_to_subscribers { |sub| sub.show_assistant_message(content, files: files) }
       end
 
+      def show_feedback_request(question, context, options)
+        emit("request_feedback", question: question, context: context, options: options)
+      end
+
       def show_tool_call(name, args)
         args_data = args.is_a?(String) ? (JSON.parse(args) rescue args) : args
 

data/lib/clacky/session_manager.rb

@@ -51,15 +51,10 @@ module Clacky
       all_sessions.find { |s| s[:session_id].to_s.start_with?(session_id.to_s) }
     end
 
-    # Physical delete — removes disk file + associated chunk files.
-    # Returns true if found and deleted, false if not found.
+    # Soft-delete: move session JSON + chunks to the session trash directory.
+    # Returns true if found and moved, false if not found.
     def delete(session_id)
-      session = all_sessions.find { |s| s[:session_id].to_s.start_with?(session_id.to_s) }
-      return false unless session
-
-      filepath = File.join(@sessions_dir, generate_filename(session[:session_id], session[:created_at]))
-      delete_session_with_chunks(filepath)
-      true
+      soft_delete(session_id)
     end
 
     # Return the on-disk files associated with a session: the main JSON file
@@ -177,7 +172,7 @@ module Clacky
         session = load_session_file(filepath)
         next unless session
         if Time.parse(session[:updated_at]) < cutoff
-          delete_session_with_chunks(filepath)
+          _hard_delete_session_with_chunks(filepath)
           deleted += 1
         end
       end
@@ -192,10 +187,44 @@ module Clacky
 
       sessions[keep..].each do |session|
         filepath = File.join(@sessions_dir, generate_filename(session[:session_id], session[:created_at]))
-        delete_session_with_chunks(filepath) if File.exist?(filepath)
+        _hard_delete_session_with_chunks(filepath) if File.exist?(filepath)
       end.size
     end
 
+    # ── Session trash (delegates to Tools::TrashManager) ──────────────
+    # All business logic lives in Clacky::Tools::TrashManager; SessionManager
+    # only provides the sessions_dir context and filesystem helpers used there.
+
+    # Soft-delete: stamp deleted_at, move JSON + chunks to sessions-trash/.
+    def soft_delete(session_id)
+      require_relative "tools/trash_manager"
+      Clacky::Tools::TrashManager.soft_delete_session(session_id, sessions_dir: @sessions_dir)
+    end
+
+    # Restore a soft-deleted session back to the active sessions directory.
+    def restore_session(session_id)
+      require_relative "tools/trash_manager"
+      Clacky::Tools::TrashManager.restore_session(session_id, sessions_dir: @sessions_dir)
+    end
+
+    # List all soft-deleted sessions (newest-first).
+    def list_trash_sessions
+      require_relative "tools/trash_manager"
+      Clacky::Tools::TrashManager.list_trash_sessions(sessions_dir: @sessions_dir)
+    end
+
+    # Permanently delete one session from the trash — cannot be undone.
+    def permanent_delete_trash_session(session_id)
+      require_relative "tools/trash_manager"
+      Clacky::Tools::TrashManager.permanent_delete_trash_session(session_id, sessions_dir: @sessions_dir)
+    end
+
+    # Clean up soft-deleted sessions older than :days (default: 90).
+    def cleanup_trash(days: 90)
+      require_relative "tools/trash_manager"
+      Clacky::Tools::TrashManager.empty_trash_sessions(sessions_dir: @sessions_dir, days: days)
+    end
+
 
     def ensure_sessions_dir
       FileUtils.mkdir_p(@sessions_dir) unless Dir.exist?(@sessions_dir)
@@ -251,10 +280,10 @@ module Clacky
     end
 
     # Delete a session JSON file and all its associated chunk MD files.
-    def delete_session_with_chunks(json_filepath)
+    private def _hard_delete_session_with_chunks(json_filepath)
       File.delete(json_filepath) if File.exist?(json_filepath)
       base = File.basename(json_filepath, ".json")
-      Dir.glob(File.join(@sessions_dir, "#{base}-chunk-*.md")).each { |f| File.delete(f) }
+      Dir.glob(File.join(File.dirname(json_filepath), "#{base}-chunk-*.md")).each { |f| File.delete(f) }
     end
 
     def load_session_file(filepath)

data/lib/clacky/skill.rb

@@ -174,11 +174,7 @@ module Clacky
     # budget — a good description is a trigger hint, not a tutorial. Authors
     # still see their full description via `skill.description`; only the
     # system-prompt rendering is truncated.
-    #
-    # Anthropic's hard limit is 1024, but empirically ~300 chars is enough for
-    # reliable triggering (including trigger-phrase lists); longer content
-    # belongs in the SKILL.md body.
-    DESCRIPTION_MAX_CHARS = 300
+    DESCRIPTION_MAX_CHARS = 340
 
     # Get the description for context loading.
     # Returns the description from frontmatter (or first paragraph of content),

data/lib/clacky/skill_loader.rb

@@ -2,6 +2,7 @@
 
 require "pathname"
 require "fileutils"
+require "set"
 require "clacky"
 
 module Clacky
@@ -34,10 +35,21 @@ module Clacky
       @skills_by_command = {} # Map slash_command -> Skill
       @errors = []            # Store loading errors
       @loaded_from = {}       # Track which location each skill was loaded from
+      @virtual_skill_providers = []  # Objects responding to #virtual_skills (e.g. Mcp::Registry)
 
       load_all
     end
 
+    # Register an object that supplies virtual (in-memory) skills. The object
+    # must respond to #virtual_skills returning an Array<Skill>. Virtual skills
+    # are merged on every #all_skills / #find_by_name call so a registry can
+    # add or remove servers at runtime without forcing a full reload.
+    # @param provider [#virtual_skills]
+    def attach_virtual_skill_provider(provider)
+      return unless provider.respond_to?(:virtual_skills)
+      @virtual_skill_providers << provider unless @virtual_skill_providers.include?(provider)
+    end
+
     # Load all skills from configured locations
     # Clears previously loaded skills before loading to ensure idempotency
     # @return [Array<Skill>] Loaded skills
@@ -139,31 +151,50 @@ module Clacky
       load_skills_from_directory(project_clacky_dir, :project_clacky)
     end
 
-    # Get all loaded skills
+    # Get all loaded skills (including virtual skills supplied by attached providers)
     # @return [Array<Skill>]
     def all_skills
-      @skills.values
+      base = @skills.values
+      virtuals = collect_virtual_skills
+      return base if virtuals.empty?
+
+      # Real skills always shadow virtuals when names collide — protects against
+      # an MCP server accidentally named after a real skill.
+      seen = base.map(&:identifier).to_set
+      base + virtuals.reject { |s| seen.include?(s.identifier) }
     end
 
     # Get a skill by its identifier
     # @param identifier [String] Skill name or directory name
     # @return [Skill, nil]
     def [](identifier)
-      @skills[identifier]
+      @skills[identifier] || virtual_skill(identifier)
     end
 
     # Find a skill by its slash command
     # @param command [String] e.g., "/explain-code"
     # @return [Skill, nil]
     def find_by_command(command)
-      @skills_by_command[command]
+      @skills_by_command[command] || collect_virtual_skills.find { |s| s.slash_command == command }
     end
 
     # Find a skill by its name (identifier)
     # @param name [String] Skill identifier (e.g., "code-explorer", "pptx")
     # @return [Skill, nil]
     def find_by_name(name)
-      @skills[name]
+      @skills[name] || virtual_skill(name)
+    end
+
+    private def virtual_skill(name)
+      collect_virtual_skills.find { |s| s.identifier == name }
+    end
+
+    private def collect_virtual_skills
+      return [] if @virtual_skill_providers.empty?
+      @virtual_skill_providers.flat_map { |p| Array(p.virtual_skills) }
+    rescue StandardError => e
+      @errors << "Virtual skill provider failed: #{e.message}"
+      []
     end
 
     # Get skills that can be invoked by user