openclacky 1.5.5 → 1.5.7

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
@@ -49,7 +51,6 @@ module Clacky
                 :latest_latency,  # Hash of latency metrics from the most recent LLM call (see Client#send_messages_with_tools)
                 :reasoning_effort
     attr_accessor :pinned
-    attr_accessor :hidden
     attr_accessor :channel_info
     attr_accessor :project_id
 
@@ -80,15 +81,15 @@ module Clacky
       @source = source.to_sym  # :manual | :cron | :channel
       @channel_info = nil  # { platform:, user_id:, user_name:, chat_id: } set by ChannelManager
       @tool_registry = ToolRegistry.new
-      @hooks = HookManager.new
+      @hooks = HookManager.new(agent: self)
       @session_id = session_id
       @name = ""
       @pinned = false
-      @hidden = false
       @history = MessageHistory.new
       @todos = []  # Store todos in memory
       @iterations = 0
       @total_cost = 0.0
+      @cost_mutex = Mutex.new
       @cache_stats = {
         cache_creation_input_tokens: 0,
         cache_read_input_tokens: 0,
@@ -108,7 +109,7 @@ module Clacky
       @ui = ui  # UIController for direct UI interaction
       @debug_logs = []  # Debug logs for troubleshooting
       @pending_injections = []     # Pending inline skill injections to flush after observe()
-      @pending_subagent_transcript = nil # Subagent trail to attach to the next tool result (observe)
+      @pending_subagent_transcripts = {} # tool_call_id => subagent trail, attached by observe()
       @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)
@@ -169,6 +170,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 +268,191 @@ 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
+
+    # Emit a custom extension event to the UI.
+    #
+    # `type` must be namespaced "ext.<extension>.<event>" so custom events can
+    # never collide with the built-in protocol.
+    #
+    # Transient by default: progress ticks and other high-frequency chatter are
+    # pushed live and forgotten, so extensions cannot bloat session.json without
+    # opting in. Pass `persist: true` for milestone events that must reappear in
+    # the chat stream after a reload; those are anchored to the current message,
+    # survive compression via the chunk MD, and are replayed in place.
+    def emit_event(type, persist: false, **data)
+      name = type.to_s
+      unless name.start_with?("ext.")
+        raise ArgumentError, "custom event type must be namespaced as 'ext.<extension>.<event>', got #{name.inspect}"
+      end
+
+      @ui&.emit(name, **data)
+      @history.append_ext_event({ type: name, data: data }) if persist
+      self
+    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 +464,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 +877,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
@@ -943,6 +1159,13 @@ module Clacky
           next
         end
 
+        # A hook fulfilled the call itself (e.g. an extension that runs the
+        # skill on its own subagents). Its result stands in for the tool's.
+        if hook_result[:action] == :handled
+          results << build_success_result(call, hook_result[:result])
+          next
+        end
+
         # Show preview for edit and write tools even in auto-approve mode
         if should_auto_execute?(call[:name], call[:arguments])
           # In auto-approve mode, show preview for edit and write tools
@@ -1000,10 +1223,13 @@ module Clacky
             args[:todos_storage] = @todos
           end
 
-          # Special handling for InvokeSkill: inject agent and skill_loader
+          # Special handling for InvokeSkill: inject agent and skill_loader.
+          # tool_call_id lets the subagent transcript be keyed to *this* call, so
+          # multiple invoke_skill calls in one turn don't cross-attach trails.
           if call[:name] == "invoke_skill"
             args[:agent] = self
             args[:skill_loader] = @skill_loader
+            args[:tool_call_id] = call[:id]
           end
 
           # Inject working_dir so tools don't rely on Dir.chdir global state
@@ -1063,9 +1289,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
@@ -1152,7 +1381,7 @@ module Clacky
         @history.append(truncated.merge(task_id: @current_task_id))
       end
 
-      attach_pending_subagent_transcript(response)
+      attach_pending_subagent_transcripts(response)
 
       # Append a follow-up `role:"user"` message for any image payloads that
       # could not be delivered inside the tool message.
@@ -1197,22 +1426,24 @@ module Clacky
       end
     end
 
-    # Attach the captured subagent transcript (set by execute_skill_with_subagent)
-    # to the invoke_skill tool result message just appended by observe(). The
-    # transcript rides on the tool message as :subagent_transcript — an internal
-    # field stripped before the LLM call but persisted to session.json and
-    # replayed to the WebUI. Cleared after attaching so it fires exactly once.
-    private def attach_pending_subagent_transcript(response)
-      transcript = @pending_subagent_transcript
-      return unless transcript
+    # Attach captured subagent transcripts (set by execute_skill_with_subagent)
+    # to their own invoke_skill tool result messages just appended by observe().
+    # Each transcript rides on its tool message as :subagent_transcript — an
+    # internal field stripped before the LLM call but persisted to session.json
+    # and replayed to the WebUI. Keyed by tool_call_id so a turn with several
+    # invoke_skill calls attaches each subagent's trail to the call that spawned
+    # it. Consumed entries are deleted so each fires exactly once.
+    private def attach_pending_subagent_transcripts(response)
+      return if @pending_subagent_transcripts.empty?
 
-      @pending_subagent_transcript = nil
+      Array(response[:tool_calls]).each do |tc|
+        next unless (tc[:name] || tc.dig(:function, :name)) == "invoke_skill"
 
-      skill_call = Array(response[:tool_calls]).find { |tc| (tc[:name] || tc.dig(:function, :name)) == "invoke_skill" }
-      target_id = skill_call && skill_call[:id]
-      return unless target_id
+        transcript = @pending_subagent_transcripts.delete(tc[:id])
+        next unless transcript
 
-      @history.attach_to_tool_result(target_id, :subagent_transcript, transcript)
+        @history.attach_to_tool_result(tc[:id], :subagent_transcript, transcript)
+      end
     end
 
     # Cap oversized tool result content to keep a single tool message from
@@ -1388,8 +1619,67 @@ module Clacky
       parent_count = subagent.instance_variable_get(:@parent_message_count) || 0
       result = subagent.run(task)
 
-      @total_cost += result[:total_cost_usd] || 0.0
+      # A detached run stays invisible, so its cost is merged silently — the
+      # sessionbar refresh would be the one thing that gives it away.
+      absorb_subagent_cost(result, notify_ui: false)
+
+      final_assistant_text(subagent, parent_count)
+    end
+
+    # Run several independent tasks on forked subagents at the same time.
+    #
+    # Each subagent is forked on the calling thread (forking deep-copies parent
+    # config + history, which must not race) and only the blocking run is moved
+    # onto the pool. Results keep the order of `tasks`; a task that raises or
+    # overruns the budget yields a failed slot instead of aborting its siblings.
+    #
+    # Subagents run silently by default: they share the parent's session, so a
+    # live UI would interleave several raw transcripts into one chat.
+    #
+    # @param tasks [Array<String>] one prompt per subagent
+    # @param model [String, nil] model for every subagent (nil = current)
+    # @param forbidden_tools [Array<String>] tool names blocked at runtime
+    # @param max_concurrency [Integer] subagents allowed to run at once
+    # @param timeout [Numeric, nil] wall-clock budget for the whole batch
+    # @return [Array<Fanout::Result>] value is the subagent's final reply text
+    def fan_out_subagents(tasks, model: nil, forbidden_tools: [], max_concurrency: Fanout::DEFAULT_MAX_CONCURRENCY,
+                          timeout: nil)
+      return [] if tasks.empty?
+
+      jobs = tasks.each_with_index.map do |task, index|
+        subagent = fork_subagent(
+          model: model,
+          forbidden_tools: forbidden_tools,
+          system_prompt_suffix: "You are one of several subagents running in parallel on independent tasks. " \
+                                "Do your task and return only the requested output. Do not ask follow-up questions."
+        )
+        parent_count = subagent.instance_variable_get(:@parent_message_count) || 0
+        label = "Subagent #{index + 1}/#{tasks.size}"
+        # Fanout workers are fresh threads, so the epoch that lets the web
+        # broadcaster drop events from superseded tasks has to be carried over
+        # by hand — otherwise interrupted subagents keep writing to the new task.
+        epoch = Thread.current[:task_epoch]
+
+        lambda do
+          Thread.current[:task_epoch] = epoch
+          within_phase(label, kind: "fanout_subagent", concurrent: true) do
+            result = subagent.run(task)
+            absorb_subagent_cost(result, notify_ui: false)
+            final_assistant_text(subagent, parent_count)
+          end
+        end
+      end
+
+      Fanout.new(max_concurrency: max_concurrency, timeout: timeout).run(jobs)
+    end
+
+    private def within_phase(label, kind:, concurrent:, &block)
+      return yield unless @ui.respond_to?(:with_phase)
+
+      @ui.with_phase(kind: kind, label: label, concurrent: concurrent, &block)
+    end
 
+    private def final_assistant_text(subagent, parent_count)
       new_messages = subagent.history.to_a[parent_count..] || []
       new_messages
         .reverse

data/lib/clacky/anthropic_stream_aggregator.rb

@@ -121,7 +121,12 @@ module Clacky
 
     private def emit_usage_progress
       return unless @on_chunk
-      input  = @usage["input_tokens"].to_i + @usage["cache_read_input_tokens"].to_i
+      raw_input      = @usage["input_tokens"].to_i
+      cache_read     = @usage["cache_read_input_tokens"].to_i
+      cache_creation = @usage["cache_creation_input_tokens"].to_i
+      # Mirrors MessageFormat::Anthropic.parse_response so the live readout and
+      # the final billed numbers agree.
+      input = MessageFormat::Anthropic.normalise_prompt_tokens(raw_input, cache_read, cache_creation)
       output = @usage["output_tokens"].to_i
       return if input == @last_input_tokens && output == @last_output_tokens
       @last_input_tokens = input

data/lib/clacky/cli.rb

@@ -8,6 +8,7 @@ require_relative "json_ui_controller"
 require_relative "plain_ui_controller"
 require_relative "brand_config"
 require_relative "extension/cli_commands"
+require_relative "mcp/cli_commands"
 
 module Clacky
   class CLI < Thor
@@ -330,7 +331,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 +385,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 +660,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 +683,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 +720,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 +802,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 +811,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 +951,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 +1060,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 +1101,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
 
@@ -1217,6 +1218,9 @@ module Clacky
     desc "ext SUBCOMMAND", "Manage extension containers (new, verify, list, pack, install, publish, search)"
     subcommand "ext", Clacky::CliExtensionCommands
 
+    desc "mcp SUBCOMMAND", "Manage MCP server connections and OAuth authorization"
+    subcommand "mcp", Clacky::Mcp::CliCommands
+
     desc "billing", "Show billing summary and usage statistics"
     long_desc <<-LONGDESC
       Display billing summary with token usage and cost breakdown.

data/lib/clacky/client.rb

@@ -415,7 +415,7 @@ module Clacky
         if defined?(Clacky::Logger)
           Clacky::Logger.warn("[parse_simple_openai_response] no content. status=#{response.status} body=#{snippet}")
         end
-        raise Clacky::Error,
+        raise RetryableError,
           "Upstream OpenAI-compatible response missing choices[0].message.content. " \
           "Body snippet: #{snippet}"
       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