openclacky 1.5.4 → 1.5.6

data/lib/clacky/agent.rb

@@ -25,6 +25,8 @@ require_relative "agent/skill_evolution"
 require_relative "agent/skill_reflector"
 require_relative "agent/skill_auto_creator"
 require_relative "agent/fake_tool_call_detector"
+require_relative "agent/goal_state"
+require_relative "agent/goal_manager"
 
 module Clacky
   class Agent
@@ -53,7 +55,7 @@ module Clacky
     attr_accessor :channel_info
     attr_accessor :project_id
 
-    REASONING_EFFORTS = %w[low medium high xhigh].freeze
+    REASONING_EFFORTS = %w[low medium high xhigh max].freeze
 
     def permission_mode
       @config&.permission_mode&.to_s || ""
@@ -169,6 +171,9 @@ module Clacky
 
       # Ensure bundled shell scripts are in place (~/.clacky/scripts/)
       Utils::ScriptsManager.setup!
+
+      # Ensure bundled search providers are in place (~/.clacky/searchers/)
+      Utils::SearcherManager.setup!
     end
 
     # Restore from a saved session
@@ -264,6 +269,170 @@ module Clacky
       @config.effective_model_name
     end
 
+    # ── /goal (Ralph-style standing goal loop) ────────────────────────────
+
+    # Lazily-built GoalManager bound to this session. The judge routes through
+    # this agent's Client on a lightweight model (the provider's lite model
+    # when available, else the primary model) — a cheap side call that never
+    # touches conversation history.
+    def goal_manager
+      @goal_manager ||= GoalManager.new(
+        judge_client: @client,
+        judge_model:  judge_model_name
+      )
+    end
+
+    # True if a standing goal loop is active for this session.
+    def goal_active?
+      @goal_manager&.active? || false
+    end
+
+    # Resolve the model name the goal judge should use. Prefer the provider's
+    # lite model (cheap/fast for a one-line verdict); fall back to the primary
+    # model when no lite is resolvable.
+    private def judge_model_name
+      lite = @config.lite_model_config_for_current
+      (lite && lite["model"]) || current_model
+    end
+
+    # Parse and handle a /goal command typed by the user. Returns a hash:
+    #   { handled: true,  result: <lightweight result> }  — command consumed, no turn
+    #   { handled: false, user_input: <text|nil> }         — fall through to a normal turn
+    #     (user_input set when `/goal <text>` seeds the first working prompt)
+    private def handle_goal_command(user_input)
+      text = user_input.to_s.strip
+      return { handled: false } unless text.start_with?("/goal", "/subgoal")
+
+      _cmd, rest = text.split(/\s+/, 2)
+      rest = rest.to_s.strip
+
+      # Sub-command dispatch: status/show/pause/resume/clear take no goal text.
+      case rest.downcase
+      when "status", "show"
+        return goal_command_reply(goal_manager.status_line)
+      when "pause"
+        goal_manager.pause(reason: "user-paused")
+        broadcast_goal_status
+        exit_goal_permission_mode!
+        return goal_command_reply(goal_manager.status_line)
+      when "resume"
+        if goal_manager.state.nil?
+          return goal_command_reply("No goal to resume. Set one with /goal <text>.")
+        end
+        goal_manager.resume
+        broadcast_goal_status
+        enter_goal_permission_mode!
+        # Resume runs a fresh working turn immediately.
+        return { handled: false, user_input: goal_manager.continuation_prompt }
+      when "clear", "stop"
+        goal_manager.clear
+        broadcast_goal_status
+        exit_goal_permission_mode!
+        return goal_command_reply("Goal cleared.")
+      end
+
+      # `/goal --turns N <text>` optional budget override.
+      max_turns = nil
+      if (m = rest.match(/\A--turns\s+(\d+)\s+(.*)\z/m))
+        max_turns = m[1].to_i
+        rest = m[2].strip
+      end
+
+      if rest.empty?
+        return goal_command_reply(goal_manager.status_line)
+      end
+
+      goal_manager.set(rest, max_turns: max_turns)
+      broadcast_goal_status
+      enter_goal_permission_mode!
+      @ui&.show_assistant_message("⊙ Goal set: #{rest}", files: [])
+      # Fall through: run the first working turn using the goal itself as the prompt.
+      { handled: false, user_input: rest }
+    end
+
+    # Show + persist a one-off goal control-plane reply (no LLM turn) and return
+    # a lightweight success result compatible with build_result's shape.
+    private def goal_command_reply(message)
+      @ui&.show_assistant_message(message, files: [])
+      { handled: true, result: goal_control_result }
+    end
+
+    private def goal_control_result
+      {
+        status: :success,
+        session_id: @session_id,
+        model: current_model,
+        provider: current_provider,
+        iterations: 0,
+        duration_seconds: 0.0,
+        total_cost_usd: 0.0,
+        cost_source: :estimated,
+        cache_stats: @cache_stats,
+        history: @history,
+        error: nil,
+        goal_command: true
+      }
+    end
+
+    # After a completed turn, consult the judge and, if the goal should keep
+    # going, run the next turn in this thread. Returns the final result of the
+    # continued run, or nil when no continuation happened.
+    private def maybe_continue_goal(result)
+      return nil unless @goal_manager&.active?
+
+      decision = @goal_manager.evaluate_after_turn(last_assistant_text)
+      broadcast_goal_status
+
+      unless decision[:message].to_s.empty?
+        @ui&.show_assistant_message(decision[:message], files: [])
+      end
+
+      unless decision[:should_continue]
+        exit_goal_permission_mode!
+        return nil
+      end
+
+      return nil unless decision[:continuation_prompt]
+
+      run(decision[:continuation_prompt])
+    end
+
+    # The agent's final assistant text this turn — what the judge evaluates.
+    private def last_assistant_text
+      msg = @history.to_a.reverse.find { |m| m[:role].to_s == "assistant" }
+      return "" unless msg
+      content = msg[:content]
+      return content if content.is_a?(String)
+      Array(content).filter_map { |c| c.is_a?(Hash) ? (c[:text] || c["text"]) : c }.join("\n")
+    end
+
+    # Emit a goal_status event over the UI bridge (Web UI live update). No-op
+    # when the UI adapter does not implement it (e.g. plain CLI).
+    private def broadcast_goal_status
+      return unless @ui.respond_to?(:show_goal_status)
+      @ui.show_goal_status(@goal_manager&.to_h)
+    end
+
+    private def enter_goal_permission_mode!
+      return unless @config&.permission_mode
+      return if @config.permission_mode == :auto_approve
+      @pre_goal_permission_mode = @config.permission_mode
+      @config.permission_mode = :auto_approve
+      notify_permission_mode_change(:auto_approve)
+    end
+
+    private def exit_goal_permission_mode!
+      return unless @pre_goal_permission_mode
+      mode = @pre_goal_permission_mode
+      @pre_goal_permission_mode = nil
+      @config.permission_mode = mode
+      notify_permission_mode_change(mode)
+    end
+
+    private def notify_permission_mode_change(mode)
+      @ui&.update_permission_mode(mode) if @ui&.respond_to?(:update_permission_mode)
+    end
+
     private def current_provider
       return nil unless @client.respond_to?(:provider_id)
       @client.provider_id
@@ -275,6 +444,21 @@ module Clacky
     end
 
     def run(user_input, files: [], display_text: nil, created_at: 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.
+      goal_intercept = handle_goal_command(user_input)
+      return goal_intercept[:result] if goal_intercept[:handled]
+      user_input = goal_intercept[:user_input] if goal_intercept[:user_input]
+
+      # Auto-clear a finished/paused goal when the user starts a new non-goal
+      # task. /goal <text> already replaced the goal above; control commands
+      # returned early. The "✓ Goal achieved" line stays in the thread.
+      if !goal_intercept[:user_input] && @goal_manager&.state && !@goal_manager.active?
+        @goal_manager.clear
+        broadcast_goal_status
+      end
+
       # Show the "thinking" indicator as early as possible so the user gets
       # immediate feedback after sending a message. Without this the UI stays
       # silent during synchronous setup work (system prompt assembly, file
@@ -673,6 +857,18 @@ module Clacky
           )
         end
         @hooks.trigger(:on_complete, result)
+
+        # Standing-goal loop: after a completed turn, ask the judge whether the
+        # goal is met. If not (and budget/health allow), auto-run the next turn
+        # in this same thread. Skipped for subagents and interrupts.
+        # awaiting_user_feedback (agent ended with '?') is intentionally not
+        # checked here - maybe_continue_goal is a no-op when no goal is active,
+        # and when one is active the judge decides done/continue, not punctuation.
+        unless @is_subagent || task_interrupted
+          continuation = maybe_continue_goal(result)
+          return continuation if continuation
+        end
+
         result
       rescue Clacky::AgentInterrupted
         # Mark this run as interrupted so the next run() (e.g. user's
@@ -1063,9 +1259,12 @@ module Clacky
           # Hook: after_tool_use
           @hooks.trigger(:after_tool_use, call, result)
 
-          # Update todos display after todo_manager execution
+          # Update todos display after todo_manager execution.
+          # Skip the broadcast for read-only "list" queries — they don't
+          # mutate state, so pushing a WS event just adds noise.
           if call[:name] == "todo_manager"
-            @ui&.update_todos(@todos.dup)
+            action = args[:action] || args["action"]
+            @ui&.update_todos(@todos.dup) unless action == "list"
           end
 
           # Special handling for request_user_feedback: emit as interactive feedback card

data/lib/clacky/agent_config.rb

@@ -159,7 +159,7 @@ module Clacky
     DEFAULT_MESSAGE_COUNT_THRESHOLD = 200
 
     attr_accessor :permission_mode, :max_tokens, :verbose,
-                  :enable_compression, :enable_prompt_caching,
+                  :enable_compression, :enable_idle_compression, :enable_prompt_caching,
                   :compression_threshold, :message_count_threshold,
                   :models, :current_model_index, :current_model_id,
                   :memory_update_enabled, :skill_evolution,
@@ -173,6 +173,7 @@ module Clacky
       @max_tokens = options[:max_tokens] || 16384
       @verbose = options[:verbose] || false
       @enable_compression = options[:enable_compression].nil? ? true : options[:enable_compression]
+      @enable_idle_compression = options[:enable_idle_compression].nil? ? true : options[:enable_idle_compression]
       # Enable prompt caching by default for cost savings
       @enable_prompt_caching = options[:enable_prompt_caching].nil? ? true : options[:enable_prompt_caching]
       # Token threshold that triggers proactive history compression. Local models
@@ -411,7 +412,7 @@ module Clacky
     # Settings keys that are persisted to config.yml.
     # These map directly to AgentConfig accessors.
     CONFIG_SETTINGS_KEYS = %w[
-      enable_compression enable_prompt_caching
+      enable_compression enable_idle_compression enable_prompt_caching
       compression_threshold message_count_threshold
       memory_update_enabled
       skill_evolution max_running_agents max_idle_agents
@@ -428,6 +429,7 @@ module Clacky
       end
       settings = {
         "enable_compression" => @enable_compression,
+        "enable_idle_compression" => @enable_idle_compression,
         "enable_prompt_caching" => @enable_prompt_caching,
         "compression_threshold" => @compression_threshold,
         "message_count_threshold" => @message_count_threshold,

data/lib/clacky/agent_profile.rb

@@ -53,8 +53,11 @@ module Clacky
 
     # List all available agent profiles across user + extension layers.
     # Precedence on id collision: user override → extension unit.
+    # @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: }
-    def self.all
+    def self.all(recency: {})
       out = {}
 
       add = lambda do |id, title, title_zh, description, description_zh, source, order, layer, author, avatar|
@@ -76,6 +79,7 @@ module Clacky
       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}"
@@ -102,8 +106,26 @@ module Clacky
         )
       end
 
-      source_rank = { "user" => 0, "extension" => 1 }
-      out.values.sort_by { |a| [source_rank[a[:source]] || 9, a[:order] || 999, a[:id]] }
+      # Builtin agents always come first, then user overrides, then third-party
+      # extension agents — so the "start new session" grid keeps the official
+      # agents grouped ahead of anything the user installed from the market.
+      # Within the third-party group, agents are ordered by most-recently-used
+      # first (via `recency`), falling back to their static `order` field for
+      # agents that have never been used yet.
+      layer_rank = lambda do |a|
+        next 0 if a[:layer] == "builtin"
+        next 1 if a[:source] == "user"
+
+        2
+      end
+      out.values.sort_by do |a|
+        rank = layer_rank.call(a)
+        if rank == 2
+          [rank, -(recency[a[:id]] || 0), a[:order] || 999, a[:id]]
+        else
+          [rank, a[:order] || 999, a[:id]]
+        end
+      end
     end
 
     private_class_method def self.read_profile_yml(path)

data/lib/clacky/cli.rb

@@ -330,7 +330,7 @@ module Clacky
 
         # The overlay lives in the session file (not config.yml), so persist it
         # now — otherwise it would be lost if the user quits before the next task.
-        session_manager&.save(agent.to_session_data)
+        session_manager&.save(agent.to_session_data(updated_at: Time.now))
 
         ui_controller.config[:model] = config.model_name
         ui_controller.update_sessionbar(
@@ -384,7 +384,7 @@ module Clacky
 
           # Save session after switch
           if session_manager
-            session_manager.save(agent.to_session_data(status: :success))
+            session_manager.save(agent.to_session_data(status: :success, updated_at: Time.now))
           end
         rescue StandardError => e
           ui_controller.show_error("Time Machine failed: #{e.message}")
@@ -659,11 +659,11 @@ module Clacky
         ui_controller.set_idle_status
 
         if exception.is_a?(Clacky::AgentInterrupted)
-          session_manager&.save(agent.to_session_data(status: :interrupted))
+          session_manager&.save(agent.to_session_data(status: :interrupted, updated_at: Time.now))
           ui_controller.show_warning("Task interrupted by user")
         else
           error_message = format_error(exception)
-          session_manager&.save(agent.to_session_data(status: :error, error_message: error_message))
+          session_manager&.save(agent.to_session_data(status: :error, error_message: error_message, updated_at: Time.now))
           code = exception.is_a?(Clacky::InsufficientCreditError) ? exception.error_code : nil
           ui_controller.show_error("Error: #{exception.message}", code: code)
         end
@@ -682,7 +682,7 @@ module Clacky
         begin
           files = prepare_non_interactive_files(file_paths)
         rescue => e
-          session_manager&.save(agent.to_session_data(status: :error, error_message: format_error(e)))
+          session_manager&.save(agent.to_session_data(status: :error, error_message: format_error(e), updated_at: Time.now))
 
           if is_json
             ui = Clacky::JsonUIController.new
@@ -719,14 +719,14 @@ module Clacky
           begin
             auto_name_session(agent, message)
             agent.run(message, files: files)
-            session_manager&.save(agent.to_session_data(status: :success))
+            session_manager&.save(agent.to_session_data(status: :success, updated_at: Time.now))
             exit(0)
           rescue Clacky::AgentInterrupted
-            session_manager&.save(agent.to_session_data(status: :interrupted))
+            session_manager&.save(agent.to_session_data(status: :interrupted, updated_at: Time.now))
             $stderr.puts "\nInterrupted."
             exit(1)
           rescue => e
-            session_manager&.save(agent.to_session_data(status: :error, error_message: format_error(e)))
+            session_manager&.save(agent.to_session_data(status: :error, error_message: format_error(e), updated_at: Time.now))
             $stderr.puts "Error: #{e.message}"
             exit(1)
           end
@@ -801,7 +801,7 @@ module Clacky
 
         # Final session save and shutdown
         if session_manager && agent.total_tasks > 0
-          session_manager.save(agent.to_session_data(status: :exited))
+          session_manager.save(agent.to_session_data(status: :exited, updated_at: Time.now))
         end
         json_ui.emit("done", total_cost: agent.total_cost, total_tasks: agent.total_tasks)
       end
@@ -810,15 +810,15 @@ module Clacky
       def run_json_task(agent, json_ui, session_manager)
         json_ui.set_working_status
         yield
-        session_manager&.save(agent.to_session_data(status: :success))
+        session_manager&.save(agent.to_session_data(status: :success, updated_at: Time.now))
         json_ui.update_sessionbar(tasks: agent.total_tasks, cost: agent.total_cost)
         :success
       rescue Clacky::AgentInterrupted
-        session_manager&.save(agent.to_session_data(status: :interrupted))
+        session_manager&.save(agent.to_session_data(status: :interrupted, updated_at: Time.now))
         json_ui.emit("interrupted")
         :interrupted
       rescue => e
-        session_manager&.save(agent.to_session_data(status: :error, error_message: format_error(e)))
+        session_manager&.save(agent.to_session_data(status: :error, error_message: format_error(e), updated_at: Time.now))
         json_ui.emit("error", message: e.message)
         :error
       ensure
@@ -950,7 +950,7 @@ module Clacky
 
             # Save final session state before exit
             if session_manager && agent.total_tasks > 0
-              session_data = agent.to_session_data(status: :exited)
+              session_data = agent.to_session_data(status: :exited, updated_at: Time.now)
               saved_path = session_manager.save(session_data)
 
               # Show session saved message in output area (before stopping UI)
@@ -1059,7 +1059,7 @@ module Clacky
 
               # Save session after each task
               if session_manager
-                session_manager.save(agent.to_session_data(status: :success))
+                session_manager.save(agent.to_session_data(status: :success, updated_at: Time.now))
               end
 
               # Update session bar with agent's cumulative stats
@@ -1100,7 +1100,7 @@ module Clacky
 
         # Save final session state
         if session_manager && agent.total_tasks > 0
-          session_manager.save(agent.to_session_data)
+          session_manager.save(agent.to_session_data(updated_at: Time.now))
         end
       end
 

data/lib/clacky/default_extensions/ext-studio/api/handler.rb

@@ -75,6 +75,11 @@ class ExtStudioExt < Clacky::ApiExtension
 
     brand = Clacky::BrandConfig.load
 
+    origin = presence(json_body["origin"]) || "marketplace"
+    if origin == "self" && !brand.user_licensed?
+      error!("only brand administrators can publish to a brand", status: 403)
+    end
+
     Dir.mktmpdir("clacky-ext-studio-publish") do |tmp|
       res      = Clacky::ExtensionPackager.pack(ext_id, out_dir: tmp)
       zip_data = File.binread(res.path)
@@ -96,7 +101,8 @@ class ExtStudioExt < Clacky::ApiExtension
         force:     json_body["force"] == true,
         status:    presence(json_body["status"]),
         changelog: presence(json_body["changelog"]),
-        readme:    local_readme
+        readme:    local_readme,
+        origin:    origin
       )
 
       if result[:success]
@@ -140,6 +146,28 @@ class ExtStudioExt < Clacky::ApiExtension
     json(extensions: exts)
   end
 
+  # GET /api/ext/ext-studio/published_brand
+  # List extensions published to the current brand's library. Only available to
+  # brand administrators (user-licensed); used by the publish panel to detect
+  # existing brand versions for the "publish to brand" flow.
+  get "/published_brand" do
+    brand = Clacky::BrandConfig.load
+    error!("only brand administrators can list brand extensions", status: 403) unless brand.user_licensed?
+
+    result = brand.fetch_brand_extensions!
+    error!(result[:error] || "failed to fetch brand extensions", status: 502) unless result[:success]
+
+    exts = Array(result[:extensions]).map do |ext|
+      {
+        id: ext["name"] || ext["slug"] || ext["id"],
+        name: ext["display_name"] || ext["name"],
+        version: (ext["latest_version"] || {})["version"] || ext["version"],
+        status: ext["status"] || "published"
+      }
+    end
+    json(extensions: exts)
+  end
+
   # DELETE /api/ext/ext-studio/local
   # body: { ext_id }
   # Permanently removes a local extension directory. Only allowed for

data/lib/clacky/default_extensions/ext-studio/ext.yml

@@ -9,8 +9,8 @@ contributes:
   api: api/handler.rb
   panels:
     - id: studio
-      title: Extension & Creation
-      title_zh: 扩展与创作
+      title: Creator Center
+      title_zh: 创作者中心
       description: Build, debug and publish extensions and skills
       description_zh: 开发、调试、发布扩展与 skill
       view: panels/studio/view.js
@@ -19,8 +19,8 @@ contributes:
     - id: ext-developer
       title: Extension Developer
       title_zh: 扩展开发
-      description: AI expert that helps you build, debug, and publish extensions
-      description_zh: 帮你开发、调试、发布扩展的 AI 专家
+      description: AI expert that helps you build custom AI agent workflows
+      description_zh: 帮你开发自定义 AI Agent 工作流的专家
       order: 5
       prompt: agents/ext-developer/system_prompt.md
       avatar: agents/ext-developer/avatar.png