openclacky 1.5.4 → 1.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10e414552c9ae0e3bb7a0b547f2e4da0709c83e0a0925f3b708820848e1a4cf3
-  data.tar.gz: 6caa29ccd3048e95912500be99000ae7ca883c9a5ad473ebc1bb2f243aef5cc3
+  metadata.gz: 534fd25ab5ff8361425b6aac147c7279c3a31a873467b7da03c106a5984c7f5d
+  data.tar.gz: 6623ec9d40ef5869af08b3476cb913c9cdf894dcd13c4bdd7cf49dc375085730
 SHA512:
-  metadata.gz: 26f220973c6821a411362df35ca281ef53ae58e6ab36d26651db393b31713340ca9bcf131f69bf4e6aa391eec3f4f21fc7d0d12cb4bbbdc368b6fe8068fa2dfa
-  data.tar.gz: 84faf59b60486d29a9168f847c97d7fd5670dac293f967bd713c08049612adab7f947fa38af3a7e89c4a5acc2cc8c460e9b8ebbf53c189c19a52bf7e89a44388
+  metadata.gz: 321f66b4bc0b80992c6a6bfe30da47d0ff561e6c75d912cba8e4d2a76084dc6ce54531cccadea2321d6c7a15a1ad9e2bf2362b4777a259a195a5056b7acdec4b
+  data.tar.gz: ad65e89da8c81b0b5ef33daf1ca254db77e4c409c0cf801ffc7761af4fa2b9949a122b5f18d9e0bdd96910d90a1cb21984ff4defb22cb9f14094af34f28e68a7

data/CHANGELOG.md

@@ -4,6 +4,69 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
+## [1.5.6] - 2026-08-08
+
+### Added
+- Pluggable web_search providers - drop a script into ~/.clacky/searchers/ to use Tavily, Brave, Serper, or any search API instead of DuckDuckGo/Bing scrapers; built-in engines stay as fallback
+- /goal command - Ralph-style standing goal loop with judge-driven auto-continuation
+- Right-edge chat navigator with hover preview and click-to-jump
+- Project edit modal replaces inline rename
+- Installed tab and hidden Market tab for brand users in extensions panel
+- ext-studio publish-to-brand flow with success toast
+- Todo panel with SVG icons and repositioned layout (#437 - @shipinliang)
+- Skill autocomplete with MRU sorting and constant-managed localStorage keys
+- Completion token billing-cell output style
+- Expose project_manager and project_id to extensions (#444)
+
+### Improved
+- Creator Center UI copy and button naming unified
+- Sessions list page size reduced to 10 for faster loading
+- Load-more sessions button styling refined
+
+### Fixed
+- Pagination cursor pollution and premature cron entry display in sessions list
+- updated_at default flipped to preserve instead of refresh
+- Extension packs now exclude gitignored and VCS files
+- Brand logo flash before load
+- SKILL_AC_SHOW_SYSTEM_KEY ReferenceError in skills store
+- Ruby 3.0+ endless method syntax replaced for Ruby 2.6 compatibility
+- session_update bridge shape normalized and ext-workspace teardown captured (#436 - @sundevilyang)
+
+### More
+- Retire doubao-seed-2.0-pro and doubao-seed-2.0-code models
+- Enforce 50MB size limit on extension pack output
+
+## [1.5.5] - 2026-08-04
+
+### Added
+- Ollama (Cloud) provider preset — connect to self-hosted Ollama instances with one click
+- Extension WebSocket bridge — extensions can now subscribe to session events via `Clacky.ext` bus
+- Hidden field support for extension agent profiles
+- Max reasoning effort level beyond `xhigh` (supports `max` tier)
+- Smart terminal output truncation — keeps head and tail of long output instead of cutting at the end
+- Time machine panel now attached to all views
+- Persist sort and installed filter selection across sessions in extensions panel
+- New extension button added to extensions management page header
+- Auto cleanup of trash sessions after 7 days
+
+### Improved
+- Extensions panel redesigned with system/market tabs and toggle switch
+- New-session page: replaced advanced modal with inline context bar chips; agents refresh on open with localized badges, ordered by most-recently-used
+- Overflow tooltip shown on truncated skill descriptions
+- Compression: idle and threshold switches are now separate controls
+- Extension install is now async with progress polling
+
+### Fixed
+- Ollama base URL corrected from `/api` to root domain
+- Extension WebSocket bridge included `hidden` field in verifier AGENT_KEYS
+- User message files render immediately in Web UI; local disk images proxied correctly
+- Sidebar visibility persisted across page reloads
+- Brand logo injected server-side to eliminate flash on load
+- Extension uninstall 404 resolved by normalizing slug field
+- Extension homepage link color variable corrected
+- `request_user_feedback` skill uses structured JSON example to avoid literal `\n` in output
+- `create_session` in extensions now broadcasts session update correctly
+
 ## [1.5.4] - 2026-08-01
 
 ### Added

data/lib/clacky/agent/goal_manager.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Clacky
+  # Drives the /goal Ralph-style loop for a single session.
+  #
+  # Responsibilities:
+  #   - own the GoalState lifecycle (set / pause / resume / clear)
+  #   - after each agent turn, ask a lightweight judge whether the goal is
+  #     done, then decide whether to feed the loop another turn
+  #   - enforce the turn budget and auto-pause on repeated judge failures
+  #
+  # The judge is a single stateless LLM call routed through the same Client
+  # the agent already holds (optionally on a cheaper model name). It never
+  # touches conversation history — it only sees the goal text and the agent's
+  # last response.
+  class GoalManager
+    # After this many consecutive judge-output parse failures the loop
+    # auto-pauses instead of burning the whole turn budget on a judge model
+    # that cannot follow the JSON reply contract.
+    MAX_CONSECUTIVE_JUDGE_FAILURES = 3
+
+    JUDGE_MAX_TOKENS = 512
+
+    JUDGE_SYSTEM_PROMPT = <<~PROMPT.freeze
+      You are a strict judge deciding whether an autonomous agent has achieved a user's stated goal.
+      You receive the goal text and the agent's most recent response.
+
+      Decide one verdict:
+      - "done": the goal is fully satisfied, OR the agent clearly explains the goal is
+        unachievable / blocked / needs user input (treat a genuine block as done).
+      - "continue": not done, and there is a concrete next step the agent can take now.
+        This is the default when in doubt.
+
+      Reply with ONLY a single-line JSON object, no prose, no code fences:
+      {"verdict": "done", "reason": "<one short sentence>"}
+      {"verdict": "continue", "reason": "<one short sentence>"}
+    PROMPT
+
+    CONTINUATION_PROMPT_TEMPLATE = <<~PROMPT.freeze
+      [Continuing toward your standing goal]
+      Goal: %<goal>s
+
+      Continue working toward this goal. Take the next concrete step.
+      If you believe the goal is complete, state so explicitly and stop.
+      If you are blocked and need input from the user, say so clearly and stop.
+    PROMPT
+
+    attr_reader :state
+
+    def initialize(judge_client:, judge_model:, state: nil)
+      @judge_client = judge_client
+      @judge_model = judge_model
+      @state = state
+      @consecutive_judge_failures = 0
+    end
+
+    def active?
+      @state&.active? || false
+    end
+
+    def has_goal?
+      @state && (@state.active? || @state.paused?)
+    end
+
+    # --- lifecycle ----------------------------------------------------------
+
+    def set(goal, max_turns: nil)
+      goal = goal.to_s.strip
+      raise ArgumentError, "goal text is empty" if goal.empty?
+
+      @state = GoalState.new(
+        goal: goal,
+        max_turns: max_turns || GoalState::DEFAULT_MAX_TURNS
+      )
+      @consecutive_judge_failures = 0
+      @state
+    end
+
+    def pause(reason: "user-paused")
+      return nil unless @state
+      @state.status = "paused"
+      @state.paused_reason = reason
+      @state
+    end
+
+    def resume(reset_budget: true)
+      return nil unless @state
+      @state.status = "active"
+      @state.paused_reason = nil
+      @state.turns_used = 0 if reset_budget
+      @consecutive_judge_failures = 0
+      @state
+    end
+
+    def clear
+      @state = nil
+    end
+
+    # Human-readable one-liner for /goal status and status bars.
+    def status_line
+      return "No active goal. Set one with /goal <text>." unless @state
+
+      s = @state
+      meta = "#{s.turns_used}/#{s.max_turns} turns"
+      case s.status
+      when "active"
+        "⊙ Goal (active, #{meta}): #{s.goal}"
+      when "paused"
+        extra = s.paused_reason ? " — #{s.paused_reason}" : ""
+        "⏸ Goal (paused, #{meta}#{extra}): #{s.goal}"
+      when "done"
+        "✓ Goal done (#{meta}): #{s.goal}"
+      else
+        "Goal (#{s.status}, #{meta}): #{s.goal}"
+      end
+    end
+
+    # --- the main hook, called after every agent turn ----------------------
+
+    # Judge the finished turn and decide the loop's next move.
+    #
+    # @param last_response [String] the agent's final assistant text this turn
+    # @return [Hash] decision:
+    #   {
+    #     should_continue: Boolean,          # caller should run another turn
+    #     continuation_prompt: String|nil,   # prompt to feed the next turn
+    #     status: String,                    # goal status after this turn
+    #     verdict: "done"|"continue",
+    #     reason: String,
+    #     message: String                    # user-visible one-liner
+    #   }
+    def evaluate_after_turn(last_response)
+      return inactive_decision unless @state&.active?
+
+      @state.turns_used += 1
+      @state.last_turn_at = Time.now.to_f
+
+      last_response = last_response.to_s
+      if last_response.strip.empty?
+        # Nothing to judge — treat as a transient blip, keep going if budget allows.
+        return continue_or_pause("empty response (nothing to evaluate)")
+      end
+
+      verdict, reason = judge(@state.goal, last_response)
+      @state.last_verdict = verdict
+      @state.last_reason = reason
+
+      if verdict.nil?
+        @consecutive_judge_failures += 1
+        if @consecutive_judge_failures >= MAX_CONSECUTIVE_JUDGE_FAILURES
+          return pause_decision(
+            "judge returned unusable output #{@consecutive_judge_failures} turns in a row"
+          )
+        end
+        return continue_or_pause("judge output unusable — continuing")
+      end
+
+      @consecutive_judge_failures = 0
+
+      if verdict == "done"
+        @state.status = "done"
+        return {
+          should_continue: false,
+          continuation_prompt: nil,
+          status: "done",
+          verdict: "done",
+          reason: reason,
+          message: "✓ Goal achieved: #{reason}"
+        }
+      end
+
+      continue_or_pause(reason)
+    end
+
+    # --- persistence bridge -------------------------------------------------
+
+    def to_h
+      @state&.to_h
+    end
+
+    private def continue_or_pause(reason)
+      if @state.budget_exhausted?
+        return pause_decision(
+          "turn budget exhausted (#{@state.turns_used}/#{@state.max_turns})"
+        )
+      end
+
+      {
+        should_continue: true,
+        continuation_prompt: continuation_prompt,
+        status: "active",
+        verdict: "continue",
+        reason: reason,
+        message: "↻ Continuing toward goal (#{@state.turns_used}/#{@state.max_turns}): #{reason}"
+      }
+    end
+
+    private def pause_decision(reason)
+      @state.status = "paused"
+      @state.paused_reason = reason
+      {
+        should_continue: false,
+        continuation_prompt: nil,
+        status: "paused",
+        verdict: @state.last_verdict || "continue",
+        reason: reason,
+        message: "⏸ Goal paused — #{reason}. Use /goal resume to continue, or /goal clear to stop."
+      }
+    end
+
+    private def inactive_decision
+      {
+        should_continue: false,
+        continuation_prompt: nil,
+        status: @state&.status,
+        verdict: "inactive",
+        reason: "no active goal",
+        message: ""
+      }
+    end
+
+    def continuation_prompt
+      format(CONTINUATION_PROMPT_TEMPLATE, goal: @state.goal)
+    end
+
+    # Run the judge LLM call. Fail-open: any error returns [nil, reason] so the
+    # caller counts it as a parse failure (and eventually auto-pauses) rather
+    # than crashing the agent loop.
+    #
+    # @return [Array(String|nil, String)] [verdict, reason]; verdict nil on failure
+    private def judge(goal, last_response)
+      messages = [
+        { role: "system", content: JUDGE_SYSTEM_PROMPT },
+        { role: "user", content: judge_user_prompt(goal, last_response) }
+      ]
+
+      raw = @judge_client.send_messages(messages, model: @judge_model, max_tokens: JUDGE_MAX_TOKENS)
+      parse_judge_response(raw)
+    rescue StandardError => e
+      Clacky::Logger.info("goal.judge_failed", error: e.message) if defined?(Clacky::Logger)
+      [nil, "judge error: #{e.class}"]
+    end
+
+    private def judge_user_prompt(goal, last_response)
+      <<~PROMPT
+        Goal:
+        #{truncate(goal, 2000)}
+
+        Agent's most recent response:
+        #{truncate(last_response, 4000)}
+
+        Is the goal satisfied — done or continue?
+      PROMPT
+    end
+
+    # Parse the judge reply into [verdict, reason]. Fail-open: unparseable
+    # output returns [nil, reason].
+    private def parse_judge_response(raw)
+      text = raw.to_s.strip
+      return [nil, "judge returned empty response"] if text.empty?
+
+      # Strip markdown code fences the model may wrap JSON in.
+      if text.start_with?("```")
+        text = text.gsub(/\A```[a-zA-Z]*\n?/, "").gsub(/```\z/, "").strip
+      end
+
+      json = extract_json_object(text)
+      return [nil, "judge reply was not JSON"] unless json
+
+      reason = json["reason"].to_s.strip
+      reason = "no reason provided" if reason.empty?
+
+      verdict = json["verdict"].to_s.strip.downcase
+      verdict = "done" if verdict.empty? && json.key?("done") && truthy?(json["done"])
+      verdict = "continue" unless %w[done continue].include?(verdict)
+
+      [verdict, reason]
+    end
+
+    private def extract_json_object(text)
+      JSON.parse(text)
+    rescue JSON::ParserError
+      match = text.match(/\{.*\}/m)
+      return nil unless match
+      begin
+        JSON.parse(match[0])
+      rescue JSON::ParserError
+        nil
+      end
+    end
+
+    private def truthy?(value)
+      return value if value == true || value == false
+      %w[true yes 1 done].include?(value.to_s.strip.downcase)
+    end
+
+    private def truncate(text, limit)
+      str = text.to_s
+      return str if str.length <= limit
+      "#{str[0, limit]}…"
+    end
+  end
+end

data/lib/clacky/agent/goal_state.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Clacky
+  # Serializable per-session goal state for the /goal Ralph-style loop.
+  #
+  # A "goal" is a standing objective the agent works toward across multiple
+  # turns without the user re-prompting each time. After every turn a judge
+  # decides done/continue; while continuing (and under the turn budget) the
+  # loop feeds itself a continuation prompt and runs another turn.
+  class GoalState
+    DEFAULT_MAX_TURNS = 20
+
+    # active   — loop is running, judge fires after each turn
+    # paused   — stopped but recoverable via /goal resume (budget exhausted,
+    #            user pause, or repeated judge failures)
+    # done     — judge decided the goal is satisfied
+    STATUSES = %w[active paused done].freeze
+
+    attr_accessor :goal, :status, :turns_used, :max_turns,
+                  :last_verdict, :last_reason, :paused_reason,
+                  :created_at, :last_turn_at
+
+    def initialize(goal:, max_turns: DEFAULT_MAX_TURNS, status: "active",
+                   turns_used: 0, last_verdict: nil, last_reason: nil,
+                   paused_reason: nil, created_at: nil, last_turn_at: nil)
+      @goal = goal.to_s
+      @status = STATUSES.include?(status.to_s) ? status.to_s : "active"
+      @turns_used = turns_used.to_i
+      @max_turns = max_turns.to_i.positive? ? max_turns.to_i : DEFAULT_MAX_TURNS
+      @last_verdict = last_verdict
+      @last_reason = last_reason
+      @paused_reason = paused_reason
+      @created_at = created_at || Time.now.to_f
+      @last_turn_at = last_turn_at
+    end
+
+    def active?
+      @status == "active"
+    end
+
+    def paused?
+      @status == "paused"
+    end
+
+    def done?
+      @status == "done"
+    end
+
+    def budget_exhausted?
+      @turns_used >= @max_turns
+    end
+
+    def to_h
+      {
+        goal: @goal,
+        status: @status,
+        turns_used: @turns_used,
+        max_turns: @max_turns,
+        last_verdict: @last_verdict,
+        last_reason: @last_reason,
+        paused_reason: @paused_reason,
+        created_at: @created_at,
+        last_turn_at: @last_turn_at
+      }
+    end
+
+    def self.from_h(data)
+      return nil unless data.is_a?(Hash)
+
+      # Tolerate both symbol and string keys (session.json round-trips as strings).
+      get = ->(key) { data[key] || data[key.to_s] }
+      goal = get.call(:goal).to_s
+      return nil if goal.strip.empty?
+
+      new(
+        goal: goal,
+        status: get.call(:status) || "active",
+        turns_used: get.call(:turns_used),
+        max_turns: get.call(:max_turns),
+        last_verdict: get.call(:last_verdict),
+        last_reason: get.call(:last_reason),
+        paused_reason: get.call(:paused_reason),
+        created_at: get.call(:created_at),
+        last_turn_at: get.call(:last_turn_at)
+      )
+    end
+  end
+end

data/lib/clacky/agent/message_compressor_helper.rb

@@ -23,6 +23,7 @@ module Clacky
           Clacky::Logger.info(
             "Idle compression skipped",
             enable_compression: @config.enable_compression,
+            enable_idle_compression: @config.enable_idle_compression,
             previous_total_tokens: @previous_total_tokens,
             history_size: @history.size,
             idle_threshold: IDLE_COMPRESSION_THRESHOLD,
@@ -129,8 +130,10 @@ module Clacky
         # (force: true) is still allowed as a safety net for long-running subagents.
         return nil if @is_subagent && !force
 
-        # Check if compression is enabled
+        # Check if compression is enabled (master switch)
         return nil unless @config.enable_compression
+        # Idle compression has its own sub-switch under the master
+        return nil if force && !@config.enable_idle_compression
 
         # Use the larger of: API-reported tokens from last response, or current
         # estimated history size. The estimate guards the case where a single

data/lib/clacky/agent/session_serializer.rb

@@ -33,6 +33,12 @@ module Clacky
         # Restore project association (nil = no project)
         @project_id = session_data[:project_id]
 
+        # Restore standing goal state (nil = no goal). The judge client/model
+        # are rebound lazily via #goal_manager when first accessed after
+        # restore — but the persisted state must be reattached here so a
+        # restored active goal keeps its progress and continues.
+        restore_goal_state(session_data[:goal])
+
         # Restore cache statistics if available
         @cache_stats = session_data.dig(:stats, :cache_stats) || {
           cache_creation_input_tokens: 0,
@@ -120,6 +126,22 @@ module Clacky
         refresh_system_prompt
       end
 
+      # Reattach persisted goal state after a restore. Builds a fresh
+      # GoalManager (bound to this agent's judge client/model) and injects the
+      # deserialized GoalState so a restored active goal keeps its progress.
+      private def restore_goal_state(goal_data)
+        return if goal_data.nil? || goal_data.empty?
+
+        state = GoalState.from_h(goal_data)
+        @goal_manager = GoalManager.new(
+          judge_client: @client,
+          judge_model:  judge_model_name,
+          state:        state
+        )
+      rescue => e
+        Clacky::Logger.warn("restore_goal_state failed: #{e.message}")
+      end
+
       # Fill missing entries in @task_meta from @history (for sessions saved
       # before task_meta existed, or for tasks whose meta was lost). The first
       # real user message of each task supplies the title; created_at becomes
@@ -168,7 +190,7 @@ module Clacky
         latest_path = chunks.last[:path]
         broken.each { |m| m[:chunk_path] = latest_path }
 
-        session_manager.save(to_session_data(preserve_updated_at: true))
+        session_manager.save(to_session_data)
       rescue => e
         Clacky::Logger.warn("heal_missing_chunk_paths! failed: #{e.message}")
       end
@@ -183,7 +205,7 @@ module Clacky
       # @param status [Symbol] Status of the last task: :success, :error, or :interrupted
       # @param error_message [String] Error message if status is :error
       # @return [Hash] Session data ready for serialization
-      def to_session_data(status: :success, error_message: nil, raw_message: nil, updated_at: nil, preserve_updated_at: false)
+      def to_session_data(status: :success, error_message: nil, raw_message: nil, updated_at: nil)
         stats_data = {
           total_tasks: @total_tasks,
           total_iterations: @iterations,
@@ -206,7 +228,7 @@ module Clacky
           pinned: @pinned,
           hidden: @hidden,
           created_at: @created_at,
-          updated_at: (updated_at || (preserve_updated_at && @persisted_updated_at) || Time.now.iso8601).then { |v| v.is_a?(String) ? v : v.iso8601 },
+          updated_at: (updated_at || @persisted_updated_at || Time.now.iso8601).then { |v| v.is_a?(String) ? v : v.iso8601 },
           working_dir: @working_dir,
           source: @source.to_s,                      # "manual" | "cron" | "channel" | "setup"
           agent_profile: @agent_profile&.name || "", # "general" | "coding" | custom
@@ -224,6 +246,7 @@ module Clacky
             # (falling back to the current default if the model no longer exists).
             permission_mode: @config.permission_mode.to_s,
             enable_compression: @config.enable_compression,
+            enable_idle_compression: @config.enable_idle_compression,
             enable_prompt_caching: @config.enable_prompt_caching,
             max_tokens: @config.max_tokens,
             verbose: @config.verbose,
@@ -240,6 +263,7 @@ module Clacky
           },
           channel_info: @channel_info,
           project_id:   @project_id,
+          goal:         @goal_manager&.to_h,
           stats: stats_data,
           messages: @history.to_a
         }