openclacky 0.9.28 → 0.9.30

data/lib/clacky/agent/llm_caller.rb

@@ -81,10 +81,16 @@ module Clacky
           # infrastructure blips — do NOT trigger fallback.  Just retry on the current
           # model (primary or already-active fallback) up to max_retries.
           if retries <= max_retries
-            @ui&.show_warning("Network failed: #{e.message}. Retry #{retries}/#{max_retries}...")
+            @ui&.show_progress(
+              "Network failed: #{e.message}",
+              progress_type: "retrying",
+              phase: "active",
+              metadata: { attempt: retries, total: max_retries }
+            )
             sleep retry_delay
             retry
           else
+            @ui&.show_progress(progress_type: "retrying", phase: "done")
             @ui&.show_error("Network failed after #{max_retries} retries: #{e.message}")
             raise AgentError, "Network connection failed after #{max_retries} retries: #{e.message}"
           end
@@ -112,10 +118,16 @@ module Clacky
                 retry
               end
             end
-            @ui&.show_warning("#{e.message} (#{retries}/#{current_max})")
+            @ui&.show_progress(
+              e.message,
+              progress_type: "retrying",
+              phase: "active",
+              metadata: { attempt: retries, total: current_max }
+            )
             sleep retry_delay
             retry
           else
+            @ui&.show_progress(progress_type: "retrying", phase: "done")
             @ui&.show_error("LLM service unavailable after #{current_max} retries. Please try again later.")
             raise AgentError, "LLM service unavailable after #{current_max} retries"
           end

data/lib/clacky/agent/message_compressor.rb

@@ -38,16 +38,23 @@ module Clacky
       YOUR ONLY TASK: Create a comprehensive summary of the conversation above.
 
       REQUIRED RESPONSE FORMAT:
-      Your response MUST start with <analysis> or <summary> tags. No other format is acceptable.
+      First output a <topics> line listing 3-6 key topic phrases (comma-separated, concise).
+      Then output the full summary wrapped in <summary> tags.
 
-      Follow the detailed compression prompt structure provided earlier. Focus on:
+      Example format:
+      <topics>Rails setup, database config, deploy pipeline, Tailwind CSS</topics>
+      <summary>
+      ...full summary text...
+      </summary>
+
+      Focus on:
       - User's explicit requests and intents
       - Key technical concepts and code changes
       - Files examined and modified
       - Errors encountered and fixes applied
       - Current work status and pending tasks
 
-      Begin your summary NOW. Remember: PURE TEXT response only, starting with <analysis> or <summary> tags.
+      Begin your response NOW. Remember: PURE TEXT only, starting with <topics> then <summary>.
     PROMPT
 
     def initialize(client, model: nil)
@@ -109,22 +116,33 @@ module Clacky
     end
 
 
+    # Parse topics tag from compressed content.
+    # Returns the topics string if found, nil otherwise.
+    # e.g. "<topics>Rails setup, database config</topics>" → "Rails setup, database config"
+    def parse_topics(content)
+      m = content.match(/<topics>(.*?)<\/topics>/m)
+      m ? m[1].strip : nil
+    end
+
     def parse_compressed_result(result, chunk_path: nil)
       # Return the compressed result as a single assistant message
-      # Keep the <analysis> or <summary> tags as they provide semantic context
+      # Keep the <summary> tags as they provide semantic context
       content = result.to_s.strip
 
       if content.empty?
         []
       else
+        # Strip out the <topics> block — it's metadata for the chunk file, not for AI context
+        content_without_topics = content.gsub(/<topics>.*?<\/topics>\n*/m, "").strip
+
         # Inject chunk anchor so AI knows where to find original conversation
         if chunk_path
           anchor = "\n\n---\n📁 **Original conversation archived at:** `#{chunk_path}`\n" \
                    "_Use `file_reader` tool to recall details from this chunk._"
-          content = content + anchor
+          content_without_topics = content_without_topics + anchor
         end
 
-        [{ role: "assistant", content: content, compressed_summary: true, chunk_path: chunk_path }]
+        [{ role: "assistant", content: content_without_topics, compressed_summary: true, chunk_path: chunk_path }]
       end
     end
   end

data/lib/clacky/agent/message_compressor_helper.rb

@@ -17,9 +17,9 @@ module Clacky
       def trigger_idle_compression
         # Check if we should compress (force mode)
         compression_context = compress_messages_if_needed(force: true)
-        @ui&.show_idle_status(phase: :start, message: "Idle detected. Compressing conversation to optimize costs...")
+        @ui&.show_progress("Idle detected. Compressing conversation to optimize costs...", progress_type: "idle_compress", phase: "active")
         if compression_context.nil?
-          @ui&.show_idle_status(phase: :end, message: "Idle skipped.")
+          @ui&.show_progress("Idle skipped.", progress_type: "idle_compress", phase: "done")
           Clacky::Logger.info(
             "Idle compression skipped",
             enable_compression: @config.enable_compression,
@@ -137,7 +137,8 @@ module Clacky
           original_messages,
           compression_context[:recent_messages],
           chunk_index: chunk_index,
-          compression_level: compression_context[:compression_level]
+          compression_level: compression_context[:compression_level],
+          topics: @message_compressor.parse_topics(compressed_content)
         )
 
         @history.replace_all(@message_compressor.rebuild_with_compression(
@@ -165,10 +166,9 @@ module Clacky
         }
 
         # Show compression info (use estimated tokens from rebuilt history)
-        @ui&.show_info(
-          "History compressed (~#{compression_context[:original_token_count]} -> ~#{@history.estimate_tokens} tokens, " \
+        compression_summary = "History compressed (~#{compression_context[:original_token_count]} -> ~#{@history.estimate_tokens} tokens, " \
           "level #{compression_context[:compression_level]})"
-        )
+        @ui&.show_progress(compression_summary, progress_type: "idle_compress", phase: "done")
       end
 
       # Get recent messages while preserving tool_calls/tool_results pairs.
@@ -304,16 +304,21 @@ module Clacky
       # @param recent_messages [Array<Hash>] Recent messages being kept (to exclude from chunk)
       # @param chunk_index [Integer] Sequential chunk number
       # @param compression_level [Integer] Compression level
+      # @param topics [String, nil] Short topic description for chunk index card
       # @return [String, nil] Path to saved chunk file, or nil if save failed
-      def save_compressed_chunk(original_messages, recent_messages, chunk_index:, compression_level:)
+      def save_compressed_chunk(original_messages, recent_messages, chunk_index:, compression_level:, topics: nil)
         return nil unless @session_id && @created_at
 
         # Messages being compressed = original minus system message minus recent messages
         # Also exclude system-injected scaffolding (session context, memory prompts, etc.)
         # — these are internal CLI metadata and must not appear in chunk MD or WebUI history.
+        # Also exclude previous compressed_summary messages: they are index cards pointing
+        # to older chunk files and must NOT be embedded inside a new chunk, otherwise
+        # parse_chunk_md_to_rounds would follow the nested reference and create circular
+        # chunk chains (chunk-2 → chunk-1 → ... → chunk-2).
         recent_set = recent_messages.to_a
         messages_to_archive = original_messages.reject do |m|
-          m[:role] == "system" || m[:system_injected] || recent_set.include?(m)
+          m[:role] == "system" || m[:system_injected] || m[:compressed_summary] || recent_set.include?(m)
         end
 
         return nil if messages_to_archive.empty?
@@ -325,7 +330,7 @@ module Clacky
         chunk_filename = "#{base_name}-chunk-#{chunk_index}.md"
         chunk_path = File.join(sessions_dir, chunk_filename)
 
-        md_content = build_chunk_md(messages_to_archive, chunk_index: chunk_index, compression_level: compression_level)
+        md_content = build_chunk_md(messages_to_archive, chunk_index: chunk_index, compression_level: compression_level, topics: topics)
 
         File.write(chunk_path, md_content)
         FileUtils.chmod(0o600, chunk_path)
@@ -340,8 +345,9 @@ module Clacky
       # @param messages [Array<Hash>] Messages to render
       # @param chunk_index [Integer] Chunk number for metadata
       # @param compression_level [Integer] Compression level
+      # @param topics [String, nil] Short topic description extracted from LLM summary
       # @return [String] Markdown content
-      def build_chunk_md(messages, chunk_index:, compression_level:)
+      def build_chunk_md(messages, chunk_index:, compression_level:, topics: nil)
         lines = []
 
         # Front matter
@@ -351,6 +357,7 @@ module Clacky
         lines << "compression_level: #{compression_level}"
         lines << "archived_at: #{Time.now.iso8601}"
         lines << "message_count: #{messages.size}"
+        lines << "topics: #{topics}" if topics
         lines << "---"
         lines << ""
         lines << "# Session Chunk #{chunk_index}"

data/lib/clacky/agent/session_serializer.rb

@@ -529,6 +529,75 @@ module Clacky
           { name: "image_#{idx + 1}.#{ext}", mime_type: mime_type, data_url: url, path: path }
         end
       end
+
+      # Inject a chunk index card into the conversation when archived chunks exist.
+      # Lists all chunk files (path + topics + turn count) so the AI knows where to
+      # look if it needs details from past conversations. The AI can load any chunk
+      # on demand using the existing file_reader tool — no new tools required.
+      #
+      # Only re-injects when a new chunk has been added since the last injection,
+      # keeping the message list clean across multiple compressions.
+      #
+      # Cache-safe: injected as a system_injected user message in the conversation
+      # turns, never touching the system prompt.
+      def inject_chunk_index_if_needed
+        # Collect all compressed_summary messages that carry a chunk_path
+        chunk_msgs = @history.to_a.select { |m| m[:compressed_summary] && m[:chunk_path] }
+        return if chunk_msgs.empty?
+
+        # Skip if we already injected an index for this exact chunk count
+        return if @history.last_injected_chunk_count == chunk_msgs.size
+
+        # Remove any previously injected chunk index (stale — chunk count changed)
+        @history.delete_where { |m| m[:chunk_index] }
+
+        # Build index card lines
+        lines = ["## Previous Session Archives (#{chunk_msgs.size} chunk#{"s" if chunk_msgs.size > 1} available)\n"]
+        chunk_msgs.each_with_index do |msg, i|
+          path   = msg[:chunk_path].to_s
+          topics = read_chunk_topics(path)
+          turns  = read_chunk_message_count(path)
+          lines << "[CHUNK-#{i + 1}] #{path}"
+          lines << "  Topics: #{topics}" if topics
+          lines << "  Turns: #{turns}"   if turns
+          lines << ""
+        end
+        lines << "Use file_reader to load a chunk file when you need original conversation details."
+
+        @history.append({
+          role: "user",
+          content: lines.join("\n"),
+          system_injected: true,
+          chunk_index: true,
+          chunk_count: chunk_msgs.size
+        })
+      end
+
+      # Read the `topics` field from a chunk MD file's YAML front matter.
+      # Returns nil if the file is missing or has no topics field.
+      private def read_chunk_topics(chunk_path)
+        return nil unless chunk_path && File.exist?(chunk_path)
+        File.foreach(chunk_path) do |line|
+          return line.sub(/^topics:\s*/, "").strip if line.start_with?("topics:")
+          break if line.strip == "---" && $. > 1  # end of front matter
+        end
+        nil
+      rescue
+        nil
+      end
+
+      # Read the `message_count` field from a chunk MD file's YAML front matter.
+      # Returns nil if the file is missing or has no message_count field.
+      private def read_chunk_message_count(chunk_path)
+        return nil unless chunk_path && File.exist?(chunk_path)
+        File.foreach(chunk_path) do |line|
+          return line.sub(/^message_count:\s*/, "").strip.to_i if line.start_with?("message_count:")
+          break if line.strip == "---" && $. > 1
+        end
+        nil
+      rescue
+        nil
+      end
     end
   end
 end

data/lib/clacky/agent/skill_manager.rb

@@ -255,7 +255,7 @@ module Clacky
           transient: transient
         })
 
-        @ui&.show_info("Injected skill content for /#{skill.identifier}")
+        @ui&.show_info("Injected skill content for /#{skill.identifier}#{skill.name_zh.to_s.empty? ? "" : " (#{skill.name_zh})"}")
       end
 
 
@@ -405,7 +405,7 @@ module Clacky
 
         # Log which model the subagent is actually using (may differ from requested
         # when "lite" falls back to default due to no lite model configured)
-        @ui&.show_info("Subagent start: #{skill.identifier} [#{subagent.current_model_info[:model]}]")
+        @ui&.show_info("Subagent start: #{skill.identifier}#{skill.name_zh.to_s.empty? ? "" : " (#{skill.name_zh})"} [#{subagent.current_model_info[:model]}]")
 
         # Run subagent with the actual task as the sole user turn.
         # If the user typed the skill command with no arguments (e.g. "/jade-appraisal"),

data/lib/clacky/agent.rb

@@ -212,6 +212,9 @@ module Clacky
       # Inject session context (date + model) if not yet present or date has changed
       inject_session_context_if_needed
 
+      # Inject chunk index card if archived chunks exist and index is stale
+      inject_chunk_index_if_needed
+
       # Split files into vision images and disk files; downgrade oversized images to disk
       image_files, disk_files = partition_files(Array(files))
       vision_images, downgraded = resolve_vision_images(image_files)

data/lib/clacky/brand_config.rb

@@ -560,7 +560,7 @@ module Clacky
       # Record installed version in brand_skills.json (including description for
       # offline display when the remote API is unreachable).
       # encrypted: true because the ZIP contains MANIFEST.enc.json + AES-256-GCM encrypted files.
-      record_installed_skill(slug, version, skill_info["description"], encrypted: true, description_zh: skill_info["description_zh"])
+      record_installed_skill(slug, version, skill_info["description"], encrypted: true, description_zh: skill_info["description_zh"], name_zh: skill_info["name_zh"])
 
       { success: true, name: slug, version: version }
     rescue StandardError, ScriptError => e
@@ -623,7 +623,7 @@ module Clacky
       File.binwrite(enc_path, mock_content.encode("UTF-8"))
 
       # encrypted: false — mock skills store plain bytes in .enc, no MANIFEST needed.
-      record_installed_skill(slug, version, description, encrypted: false, description_zh: description_zh)
+      record_installed_skill(slug, version, description, encrypted: false, description_zh: description_zh, name_zh: skill_info["name_zh"])
       { success: true, name: slug, version: version }
     rescue StandardError => e
       { success: false, error: e.message }
@@ -664,11 +664,36 @@ module Clacky
           # installed and that have a newer version available.
           # New skills are never auto-installed — the user must click Install/Update
           # explicitly from the Brand Skills panel.
+          installed = installed_brand_skills
           skills_needing_update = result[:skills].select { |s| s["needs_update"] }
           results = skills_needing_update.map do |skill_info|
             install_brand_skill!(skill_info)
           end
 
+          # Even when the version hasn't changed, display metadata (name_zh,
+          # description_zh, description) may have been updated on the platform.
+          # Patch brand_skills.json in-place without re-downloading the ZIP.
+          result[:skills].each do |skill_info|
+            name = skill_info["name"]
+            next unless installed.key?(name)
+            next if skill_info["needs_update"] # already being reinstalled above
+
+            local = installed[name]
+            next if local["name_zh"]        == skill_info["name_zh"].to_s &&
+                    local["description_zh"] == skill_info["description_zh"].to_s &&
+                    local["description"]    == skill_info["description"].to_s
+
+            # Metadata changed — update brand_skills.json without reinstalling.
+            record_installed_skill(
+              name,
+              local["version"],
+              skill_info["description"].to_s,
+              encrypted:      local["encrypted"] != false,
+              description_zh: skill_info["description_zh"].to_s,
+              name_zh:        skill_info["name_zh"].to_s
+            )
+          end
+
           on_complete&.call(results)
         rescue StandardError
           # Background sync failures are intentionally swallowed — the agent
@@ -1069,7 +1094,7 @@ module Clacky
     #   1. name already valid            → use name as-is
     #   2. name invalid — sanitize       → downcase, spaces→hyphens, strip illegal chars
     #   3. still invalid after sanitize  → raise, caller gets { success: false }
-    private def record_installed_skill(name, version, description = nil, encrypted: true, description_zh: nil)
+    private def record_installed_skill(name, version, description = nil, encrypted: true, description_zh: nil, name_zh: nil)
       safe_name = sanitize_skill_name(name)
 
       FileUtils.mkdir_p(brand_skills_dir)
@@ -1078,6 +1103,7 @@ module Clacky
       installed[safe_name] = {
         "version"        => version,
         "name"           => safe_name,
+        "name_zh"        => name_zh.to_s,
         "description"    => description.to_s,
         "description_zh" => description_zh.to_s,
         "encrypted"      => encrypted,

data/lib/clacky/clacky_auth_client.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Clacky
+  # ClackyAuthClient - Fetches LLM keys from a Clacky workspace via API
+  #
+  # Usage:
+  #   client = ClackyAuthClient.new("clacky_ak_xxx", base_url: "https://api.example.com")
+  #   result = client.fetch_workspace_keys
+  #   # => { success: true, llm_key: "ABSK...", model_name: "jp.anthropic.claude-sonnet-4-6",
+  #   #      base_url: "https://...", anthropic_format: false }
+  class ClackyAuthClient
+    WORKSPACE_KEYS_PATH = "/openclacky/v1/workspace/keys"
+    REQUEST_TIMEOUT     = 15   # seconds
+    OPEN_TIMEOUT        = 5    # seconds
+
+    # Default model to use when the workspace/keys response does not specify one
+    DEFAULT_MODEL = "jp.anthropic.claude-sonnet-4-6"
+
+    def initialize(workspace_api_key, base_url:)
+      @workspace_api_key = workspace_api_key.to_s.strip
+      @base_url          = base_url.to_s.strip.sub(%r{/+$}, "")
+    end
+
+    # Fetch workspace keys from the Clacky backend.
+    #
+    # @return [Hash]
+    #   On success:
+    #     { success: true,
+    #       llm_key: "...",          # raw LLM key string returned by the API (ABSK prefix = Bedrock)
+    #       model_name: "...",       # model to configure (provider default or our default)
+    #       base_url: "...",         # LLM proxy base URL (clean host, no path suffix)
+    #       anthropic_format: false  # ABSK keys use Bedrock Converse format, not Anthropic wire format
+    #     }
+    #   On failure:
+    #     { success: false, error: "..." }
+    def fetch_workspace_keys
+      validate_inputs!
+
+      response = connection.get(WORKSPACE_KEYS_PATH)
+
+      unless response.status == 200
+        error_msg = extract_error(response)
+        return { success: false, error: "HTTP #{response.status}: #{error_msg}" }
+      end
+
+      body = JSON.parse(response.body)
+
+      unless body["code"].to_i == 200
+        return { success: false, error: "API error: #{body["msg"] || body["message"]}" }
+      end
+
+      llm_key_data = body.dig("data", "llm_key")
+      if llm_key_data.nil?
+        return { success: false, error: "No LLM key available for this workspace" }
+      end
+
+      # Extract key value – the API returns a hash with fields:
+      #   raw_key  – plaintext secret (primary field since 2026-03-30)
+      #   key      – alias used by some gateway endpoints
+      #   key_id   – legacy identifier (kept for forward-compat)
+      # Priority: raw_key > key > key_id > value
+      # We also accept a plain string form for forward-compat.
+      llm_key = case llm_key_data
+                when String then llm_key_data
+                when Hash
+                  llm_key_data["raw_key"] || llm_key_data["key"] ||
+                    llm_key_data["key_id"] || llm_key_data["value"]
+                end
+
+      if llm_key.nil? || llm_key.to_s.strip.empty?
+        return { success: false, error: "LLM key value is empty or missing in response" }
+      end
+
+      # base_url comes from the `host` field in the API response (set per environment by backend config).
+      # Fallback to @base_url (the backend URL the user entered).
+      # No path suffix is appended — the LLM key has ABSK prefix (Bedrock), so client.rb will
+      # automatically build the correct endpoint: /model/{model}/converse
+      host = llm_key_data.is_a?(Hash) ? llm_key_data["host"].to_s.strip : ""
+      llm_base_url = if host.start_with?("http://", "https://")
+                       host
+                     else
+                       @base_url
+                     end
+
+      {
+        success:          true,
+        llm_key:          llm_key.to_s.strip,
+        model_name:       DEFAULT_MODEL,
+        base_url:         llm_base_url,
+        anthropic_format: false
+      }
+    rescue Faraday::ConnectionFailed => e
+      { success: false, error: "Connection failed: #{e.message}" }
+    rescue Faraday::TimeoutError
+      { success: false, error: "Request timed out (#{REQUEST_TIMEOUT}s)" }
+    rescue Faraday::Error => e
+      { success: false, error: "Network error: #{e.message}" }
+    rescue JSON::ParserError => e
+      { success: false, error: "Invalid JSON response: #{e.message}" }
+    rescue ArgumentError => e
+      { success: false, error: e.message }
+    rescue => e
+      { success: false, error: "Unexpected error: #{e.message}" }
+    end
+
+    # Validate that inputs look reasonable before making a network request.
+    private def validate_inputs!
+      if @workspace_api_key.empty?
+        raise ArgumentError, "Workspace API key is required"
+      end
+
+      unless @workspace_api_key.start_with?("clacky_ak_")
+        raise ArgumentError, "Invalid key format (expected prefix: clacky_ak_)"
+      end
+
+      if @base_url.empty?
+        raise ArgumentError, "Base URL is required"
+      end
+
+      unless @base_url.start_with?("http://", "https://")
+        raise ArgumentError, "Base URL must start with http:// or https://"
+      end
+    end
+
+    # Build a Faraday connection pointing at the Clacky backend.
+    private def connection
+      @connection ||= Faraday.new(url: @base_url) do |conn|
+        conn.headers["Content-Type"]  = "application/json"
+        conn.headers["Authorization"] = "Bearer #{@workspace_api_key}"
+        conn.options.timeout          = REQUEST_TIMEOUT
+        conn.options.open_timeout     = OPEN_TIMEOUT
+        conn.ssl.verify               = false
+        conn.adapter Faraday.default_adapter
+      end
+    end
+
+    # Extract a human-readable error from a failed response.
+    private def extract_error(response)
+      body = JSON.parse(response.body) rescue nil
+      return response.body.to_s[0..200] unless body.is_a?(Hash)
+
+      body["msg"] ||
+        body["message"] ||
+        body.dig("error", "message") ||
+        body["error"].to_s[0..200] ||
+        response.body.to_s[0..200]
+    end
+  end
+end

data/lib/clacky/clacky_cloud_config.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Clacky
+  # ClackyCloudConfig — stores the Clacky Cloud credentials used for workspace-key
+  # import (workspace_api_key + backend base_url) in a dedicated file so the user
+  # never has to re-enter them.
+  #
+  # File location: ~/.clacky/clacky_cloud.yml
+  # File format (YAML):
+  #   workspace_key: clacky_ak_xxxx
+  #   base_url: https://api.clacky.ai
+  #   dashboard_url: https://app.clacky.ai   # optional, inferred from base_url if absent
+  #
+  # Usage:
+  #   cfg = ClackyCloudConfig.load
+  #   cfg.workspace_key   # => "clacky_ak_xxxx" or nil
+  #   cfg.base_url        # => "https://api.clacky.ai"
+  #   cfg.dashboard_url   # => "https://app.clacky.ai"  (explicit or inferred)
+  #   cfg.configured?     # => true / false
+  #
+  #   cfg.workspace_key = "clacky_ak_newkey"
+  #   cfg.save
+  class ClackyCloudConfig
+    CONFIG_DIR  = File.join(Dir.home, ".clacky")
+    CONFIG_FILE = File.join(CONFIG_DIR, "clacky_cloud.yml")
+
+    DEFAULT_BASE_URL      = "https://api.clacky.ai"
+    DEFAULT_DASHBOARD_URL = "https://app.clacky.ai"
+
+    attr_accessor :workspace_key, :base_url, :dashboard_url
+
+    def initialize(workspace_key: nil, base_url: DEFAULT_BASE_URL, dashboard_url: nil)
+      @workspace_key = workspace_key.to_s.strip
+      @workspace_key = nil if @workspace_key.empty?
+      @base_url      = (base_url.to_s.strip.empty? ? DEFAULT_BASE_URL : base_url.to_s.strip)
+                         .sub(%r{/+$}, "")  # strip trailing slash
+
+      # dashboard_url: use explicit value if provided, otherwise infer from base_url
+      explicit = dashboard_url.to_s.strip.sub(%r{/+$}, "")
+      @dashboard_url = explicit.empty? ? infer_dashboard_url(@base_url) : explicit
+    end
+
+    # Load from ~/.clacky/clacky_cloud.yml (returns an empty config if the file is absent)
+    def self.load(config_file = CONFIG_FILE)
+      if File.exist?(config_file)
+        data = YAML.safe_load(File.read(config_file)) || {}
+        new(
+          workspace_key: data["workspace_key"],
+          base_url:      data["base_url"]      || DEFAULT_BASE_URL,
+          dashboard_url: data["dashboard_url"]
+        )
+      else
+        new
+      end
+    rescue => e
+      # Corrupt file — return empty config rather than crash
+      warn "[clacky_cloud_config] Failed to load #{config_file}: #{e.message}"
+      new
+    end
+
+    # Persist to ~/.clacky/clacky_cloud.yml
+    def save(config_file = CONFIG_FILE)
+      FileUtils.mkdir_p(File.dirname(config_file))
+      File.write(config_file, to_yaml)
+      FileUtils.chmod(0o600, config_file)
+      self
+    end
+
+    # Serialize to YAML string
+    def to_yaml
+      data = { "base_url" => @base_url }
+      data["workspace_key"]  = @workspace_key  if @workspace_key
+      # Only persist dashboard_url when it differs from the inferred default,
+      # so the file stays minimal for users who don't need to override it.
+      inferred = infer_dashboard_url(@base_url)
+      data["dashboard_url"]  = @dashboard_url  if @dashboard_url != inferred
+      YAML.dump(data)
+    end
+
+    # True when a non-empty workspace_key is stored
+    def configured?
+      !@workspace_key.nil? && !@workspace_key.empty?
+    end
+
+    # Remove the saved file (used for reset / tests)
+    def self.clear!(config_file = CONFIG_FILE)
+      FileUtils.rm_f(config_file)
+    end
+
+    # Derive the dashboard web-app URL from the API base_url.
+    #
+    # Mapping rules:
+    #   https://api.clacky.ai               -> https://app.clacky.ai
+    #   https://<env>.api.clackyai.com      -> https://<env>.app.clackyai.com
+    #   http://localhost:<port>             -> http://localhost:3001
+    #   (anything else)                     -> https://app.clacky.ai  (safe default)
+    private def infer_dashboard_url(api_url)
+      return DEFAULT_DASHBOARD_URL if api_url.nil? || api_url.strip.empty?
+
+      # Production: api.clacky.ai -> app.clacky.ai
+      return "https://app.clacky.ai" if api_url == "https://api.clacky.ai"
+
+      # Staging/dev on clackyai.com: <env>.api.clackyai.com -> <env>.app.clackyai.com
+      if api_url =~ %r{\Ahttps?://(.+)\.api\.clackyai\.com\z}
+        env_prefix = Regexp.last_match(1)
+        scheme     = api_url.start_with?("https") ? "https" : "http"
+        return "#{scheme}://#{env_prefix}.app.clackyai.com"
+      end
+
+      # Local development: localhost:<port> -> localhost:3001
+      if api_url =~ %r{\Ahttps?://localhost(:\d+)?\z}
+        scheme = api_url.start_with?("https") ? "https" : "http"
+        return "#{scheme}://localhost:3001"
+      end
+
+      # Fallback: return production dashboard
+      DEFAULT_DASHBOARD_URL
+    end
+  end
+end

data/lib/clacky/cli.rb

@@ -709,8 +709,21 @@ module Clacky
             sleep 0.1
             # Clear output area
             ui_controller.layout.clear_output
+            # Cancel old idle timer before replacing agent to avoid stale-agent compression
+            idle_timer.cancel
             # Clear session by creating a new agent
             agent = Clacky::Agent.new(client, agent_config, working_dir: working_dir, ui: ui_controller, profile: agent.agent_profile.name, session_id: Clacky::SessionManager.generate_id, source: :manual)
+            # Rebuild idle timer bound to the new agent
+            idle_timer = Clacky::IdleCompressionTimer.new(
+              agent:           agent,
+              session_manager: session_manager,
+              logger:          ->(msg, level:) { ui_controller.log(msg, level: level) }
+            ) do |success|
+              if success
+                ui_controller.update_sessionbar(tasks: agent.total_tasks, cost: agent.total_cost)
+              end
+              ui_controller.set_idle_status
+            end
             ui_controller.show_info("Session cleared. Starting fresh.")
             # Update session bar with reset values
             ui_controller.update_sessionbar(tasks: agent.total_tasks, cost: agent.total_cost)