openclacky 1.2.6 → 1.2.8

data/lib/clacky/server/channel/channel_manager.rb

@@ -234,7 +234,7 @@ module Clacky
         return if (text.nil? || text.empty?) && files.empty?
 
         # Handle built-in commands
-        if text&.start_with?("/")
+        if text&.match?(KNOWN_COMMAND) || text&.match?(/\A([\?h]|help)\z/i)
           handle_command(adapter, event, text)
           return
         end
@@ -249,7 +249,8 @@ module Clacky
           return
         end
 
-        Clacky::Logger.info("[ChannelManager] Routing to session #{session_id[0, 8]} (status=#{session[:status]})")
+        sub_count = web_ui_for_session_diag(session_id)
+        Clacky::Logger.info("[ChannelManager] Routing to session #{session_id[0, 8]} (status=#{session[:status]}, text=#{text.inspect}, channel_subs=#{sub_count})")
 
         # If session is running, interrupt it automatically (mimics CLI behavior)
         if session[:status] == :running
@@ -283,7 +284,12 @@ module Clacky
 
         @run_agent_task.call(session_id, agent) do
           begin
+            Clacky::Logger.info("[ChannelManager] agent.run START session=#{session_id[0, 8]} text=#{text.inspect}")
             agent.run(text, files: files)
+            Clacky::Logger.info("[ChannelManager] agent.run END   session=#{session_id[0, 8]} text=#{text.inspect}")
+          rescue StandardError => e
+            Clacky::Logger.error("[ChannelManager] agent.run RAISED session=#{session_id[0, 8]} #{e.class}: #{e.message}\n#{e.backtrace.first(8).join("\n")}")
+            raise
           ensure
             adapter.stop_typing_keepalive(chat_id) if adapter.respond_to?(:stop_typing_keepalive)
           end
@@ -295,11 +301,24 @@ module Clacky
         key     = channel_key(event)
 
         case text
+        when /\A([\?h]|help)\z/i
+          adapter.send_text(chat_id, COMMAND_HELP)
+
+        when "/new", "/clear"
+          session_id = auto_create_session(adapter, event)
+          adapter.send_text(chat_id, "New session `#{session_id[0, 8]}` created.") if session_id
+
+        when /\A\/model\b/i
+          handle_model_command(adapter, event, text)
+
+        when /\A\/skills\b/i
+          handle_skills_command(adapter, event)
+
         when /\A\/bind\s+(\S+)\z/i
           arg = Regexp.last_match(1)
           # Support numeric index from /list (1-based)
           session_id = if arg =~ /\A\d+\z/
-            recent = @registry.list.last(5).reverse
+            recent = @registry.list.first(5)
             idx = arg.to_i - 1
             recent[idx]&.fetch(:id, nil)
           else
@@ -351,7 +370,9 @@ module Clacky
           session_id = resolve_session(event)
           if session_id
             session = @registry.get(session_id)
-            adapter.send_text(chat_id, "Bound to session `#{session_id[0, 8]}` (status: #{session&.dig(:status) || "unknown"})")
+            model = session&.dig(:agent)&.current_model_info
+            model_name = model&.dig(:model) || "unknown"
+            adapter.send_text(chat_id, "Bound to session `#{session_id[0, 8]}` (status: #{session&.dig(:status) || "unknown"}, model: #{model_name})")
           else
             adapter.send_text(chat_id, "No session bound yet. Send any message to auto-create one.")
           end
@@ -360,16 +381,118 @@ module Clacky
           list_sessions(adapter, chat_id)
 
         else
-          adapter.send_text(chat_id,
-            "Commands:\n" \
-            "  /bind <n|session_id> - switch to a session (use /list to see numbers)\n" \
-            "  /unbind - remove binding\n" \
-            "  /stop - interrupt current task\n" \
-            "  /status - show current binding\n" \
-            "  /list - show recent sessions")
+          adapter.send_text(chat_id, "Unknown command. Type ? for help.")
         end
       end
 
+      KNOWN_COMMAND = %r{\A/(new|clear|model|skills|bind|stop|unbind|status|list)\b}i
+
+      COMMAND_HELP = <<~HELP.strip
+        Commands:
+          ? / h / help - show this help
+          /new / /clear - start a new session
+          /model - show current model & available models
+          /model <n> - switch to model n
+          /skills - list available skills
+          /<skill> <args> - invoke a skill directly
+          /bind <n|session_id> - switch to a session (use /list to see numbers)
+          /unbind - remove binding
+          /stop - interrupt current task
+          /status - show current binding
+          /list - show recent sessions
+      HELP
+
+      def handle_model_command(adapter, event, text)
+        chat_id   = event[:chat_id]
+        session_id = resolve_session(event)
+
+        unless session_id
+          adapter.send_text(chat_id, "No session bound. Send any message to auto-create one first.")
+          return
+        end
+
+        session = @registry.get(session_id)
+        agent = session&.dig(:agent)
+        unless agent
+          adapter.send_text(chat_id, "Session not ready.")
+          return
+        end
+
+        arg = text.sub(/\A\/model\s*/i, "").strip
+
+        if arg.empty?
+          # Show current model and available list
+          info = agent.current_model_info
+          current = info&.dig(:model) || "unknown"
+          sub     = info&.dig(:sub_model)
+          card    = info&.dig(:card_model)
+          header  = "Current model: #{current}"
+          header += " (#{card} · #{sub})" if card && sub && sub != current
+          header += " (#{card})" if card && !sub
+
+          models = agent.available_models
+          if models.empty?
+            adapter.send_text(chat_id, "#{header}\nNo other models available.")
+            return
+          end
+
+          lines = models.each_with_index.map do |name, i|
+            marker = name == current ? " *" : ""
+            "#{i + 1}. #{name}#{marker}"
+          end
+          adapter.send_text(chat_id, "#{header}\n\nSwitch with /model <n>:\n#{lines.join("\n")}")
+        elsif arg =~ /\A\d+\z/
+          idx = arg.to_i - 1
+          models = agent.config.models
+          if idx < 0 || idx >= models.length
+            adapter.send_text(chat_id, "Invalid model number. Use /model to see available models.")
+            return
+          end
+
+          model_id = models[idx]["id"]
+          if agent.switch_model_by_id(model_id)
+            new_info = agent.current_model_info
+            adapter.send_text(chat_id, "Switched to #{new_info&.dig(:model) || model_id}.")
+          else
+            adapter.send_text(chat_id, "Failed to switch model.")
+          end
+        else
+          adapter.send_text(chat_id, "Usage: /model to list, /model <n> to switch.")
+        end
+      end
+
+      def handle_skills_command(adapter, event)
+        chat_id    = event[:chat_id]
+        session_id = resolve_session(event)
+
+        unless session_id
+          adapter.send_text(chat_id, "No session bound. Send any message to auto-create one first.")
+          return
+        end
+
+        session = @registry.get(session_id)
+        agent = session&.dig(:agent)
+        unless agent
+          adapter.send_text(chat_id, "Session not ready.")
+          return
+        end
+
+        skills = agent.skill_loader.user_invocable_skills
+          .reject { |s| s.source == :default }
+          .first(10)
+        if skills.empty?
+          adapter.send_text(chat_id, "No skills available.")
+          return
+        end
+
+        lines = skills.each_with_index.map do |s, i|
+          desc = s.description.to_s.strip
+          desc = desc.empty? ? "(no description)" : desc.length > 50 ? "#{desc[0..49]}..." : desc
+          "#{i + 1}. #{s.name} - #{desc}"
+        end
+        adapter.send_text(chat_id, "Skills:\n#{lines.join("\n")}")
+      end
+
       def resolve_session(event)
         key = channel_key(event)
         @registry.list.each do |summary|
@@ -388,7 +511,7 @@ module Clacky
         platform = event[:platform].to_s
         count    = @mutex.synchronize { @session_counters[platform] += 1 }
         name     = "#{platform}-#{count}"
-        session_id = @session_builder.call(name: name, working_dir: Dir.home, source: :channel)
+        session_id = @session_builder.call(name: name, source: :channel)
         bind_key_to_session(key, session_id)
 
         # Create a long-lived ChannelUIController for this session and subscribe it
@@ -411,6 +534,19 @@ module Clacky
         result
       end
 
+      def web_ui_for_session_diag(session_id)
+        result = nil
+        @registry.with_session(session_id) do |s|
+          ui = s[:ui]
+          result = if ui.respond_to?(:channel_subscribed?)
+            ui.instance_variable_get(:@channel_subscribers)&.size || 0
+          else
+            -1
+          end
+        end
+        result
+      end
+
       def bind_key_to_session(key, session_id)
         @registry.list.each do |summary|
           @registry.with_session(summary[:id]) { |s| s[:channel_keys]&.delete(key) }
@@ -422,7 +558,7 @@ module Clacky
       end
 
       def list_sessions(adapter, chat_id)
-        sessions = @registry.list.last(5).reverse
+        sessions = @registry.list.first(5)
         if sessions.empty?
           adapter.send_text(chat_id, "No sessions available.")
           return

data/lib/clacky/server/channel/channel_ui_controller.rb

@@ -145,8 +145,10 @@ module Clacky
         send_text("Warning: #{message}")
       end
 
-      def show_error(message)
-        send_text("Error: #{message}")
+      def show_error(message, code: nil, top_up_url: nil)
+        text = "Error: #{message}"
+        text += "\n#{top_up_url}" if top_up_url
+        send_text(text)
       end
 
       def show_success(message)

data/lib/clacky/server/channel/user_adapter_loader.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Clacky
+  module Channel
+    module Adapters
+      # Loads user-defined channel adapters from ~/.clacky/channels/<name>/adapter.rb.
+      #
+      # Each adapter file is plain Ruby that defines a subclass of
+      # Clacky::Channel::Adapters::Base and self-registers via Adapters.register,
+      # exactly like the bundled adapters. This loader only discovers and requires
+      # those files after the built-in adapters are loaded — the existing
+      # self-registration mechanism then takes over with no further wiring.
+      #
+      # A broken adapter (syntax error, missing interface methods) is isolated:
+      # it is skipped with a logged warning and never aborts the load of others.
+      module UserAdapterLoader
+        DEFAULT_DIR = File.expand_path("~/.clacky/channels")
+
+        # Required class/instance methods a user adapter must implement to be usable.
+        REQUIRED_CLASS_METHODS    = %i[platform_id platform_config].freeze
+        REQUIRED_INSTANCE_METHODS = %i[start stop send_text].freeze
+
+        Result = Struct.new(:loaded, :skipped, keyword_init: true)
+
+        # @param dir [String] directory to scan (override for tests)
+        # @return [Result] names loaded and skipped (with reasons)
+        def self.load_all(dir: DEFAULT_DIR)
+          result = Result.new(loaded: [], skipped: [])
+          if Dir.exist?(dir)
+            Dir.glob(File.join(dir, "*", "adapter.rb")).sort.each do |path|
+              name = File.basename(File.dirname(path))
+              load_one(path, name, result)
+            end
+          end
+          @last_result = result
+          result
+        end
+
+        # The result of the most recent load_all (set at startup). Lets `channel_verify`
+        # report status without re-requiring files (require is idempotent and would
+        # otherwise report already-loaded adapters as "did not register").
+        def self.last_result
+          @last_result || load_all
+        end
+
+        def self.load_one(path, name, result)
+          before = Adapters.all.dup
+
+          require path
+
+          newly = Adapters.all - before
+          klass = newly.last
+
+          unless klass
+            result.skipped << [name, "did not register an adapter (missing Adapters.register?)"]
+            log_skip(name, result.skipped.last[1])
+            return
+          end
+
+          if (missing = interface_gaps(klass)).any?
+            unregister(klass)
+            result.skipped << [name, "missing required methods: #{missing.join(", ")}"]
+            log_skip(name, result.skipped.last[1])
+            return
+          end
+
+          result.loaded << name
+          Clacky::Logger.info("[UserAdapterLoader] Loaded channel adapter '#{name}' → :#{klass.platform_id}")
+        rescue StandardError, ScriptError => e
+          result.skipped << [name, e.message]
+          log_skip(name, e.message)
+        end
+
+        def self.interface_gaps(klass)
+          missing = REQUIRED_CLASS_METHODS.reject { |m| klass.respond_to?(m) }
+          # Base defines stub instance methods that only raise NotImplementedError,
+          # so method_defined? alone passes via inheritance. Require the subclass to
+          # actually override them — i.e. the method's owner must not be Base.
+          missing += REQUIRED_INSTANCE_METHODS.reject do |m|
+            klass.method_defined?(m) && klass.instance_method(m).owner != Base
+          end
+          missing
+        end
+
+        def self.unregister(klass)
+          platform = (klass.platform_id if klass.respond_to?(:platform_id))
+          return unless platform
+
+          Adapters.unregister(platform)
+        end
+
+        def self.log_skip(name, reason)
+          Clacky::Logger.warn("[UserAdapterLoader] Skipped channel adapter '#{name}': #{reason}")
+        end
+
+        # Generate a ready-to-edit adapter skeleton at ~/.clacky/channels/<name>/adapter.rb.
+        # The skeleton already self-registers and implements the full interface with
+        # TODO markers — the author only fills in the method bodies.
+        # @return [String] path to the generated adapter.rb
+        def self.scaffold(name, dir: DEFAULT_DIR)
+          slug = name.to_s.strip.downcase.gsub(/[^a-z0-9_]+/, "_").gsub(/\A_+|_+\z/, "")
+          raise ArgumentError, "invalid channel name: #{name.inspect}" if slug.empty?
+
+          target_dir = File.join(dir, slug)
+          path = File.join(target_dir, "adapter.rb")
+          raise ArgumentError, "adapter already exists: #{path}" if File.exist?(path)
+
+          FileUtils.mkdir_p(target_dir)
+          File.write(path, skeleton(slug))
+          path
+        end
+
+        def self.skeleton(slug)
+          const = slug.split("_").map(&:capitalize).join
+          <<~RUBY
+            # frozen_string_literal: true
+
+            # User-defined channel adapter for ":#{slug}".
+            # Edit the TODO sections, then it loads automatically on next start.
+            # Verify with: clacky channel verify
+
+            module Clacky
+              module Channel
+                module Adapters
+                  class #{const}Adapter < Base
+                    def self.platform_id
+                      :#{slug}
+                    end
+
+                    # Map raw config (channels.yml `#{slug}` section) to a symbol-keyed hash.
+                    def self.platform_config(data)
+                      {
+                        # TODO: pull your credentials out of `data`
+                        # token: data["IM_#{slug.upcase}_TOKEN"] || data["token"]
+                      }.compact
+                    end
+
+                    def initialize(config)
+                      @config = config
+                    end
+
+                    # Begin receiving messages. Blocks until #stop — runs inside a Thread.
+                    # Yield one standardized event Hash per inbound message.
+                    def start(&on_message)
+                      # TODO: connect to your platform and loop, calling on_message.call(event)
+                      raise NotImplementedError
+                    end
+
+                    def stop
+                      # TODO: close connections / stop the read loop
+                    end
+
+                    # Send a plain text (or Markdown) message to a chat.
+                    # @return [Hash] { message_id: String }
+                    def send_text(chat_id, text, reply_to: nil)
+                      # TODO: call your platform's send API
+                      raise NotImplementedError
+                    end
+
+                    # Optional: validate config; return array of error strings (empty = ok).
+                    def validate_config(config)
+                      []
+                    end
+
+                    Adapters.register(platform_id, self)
+                  end
+                end
+              end
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/clacky/server/channel.rb

@@ -31,3 +31,8 @@ require_relative "channel/adapters/dingtalk/adapter"
 require_relative "channel/channel_config"
 require_relative "channel/channel_ui_controller"
 require_relative "channel/channel_manager"
+
+# Discover and load user-defined adapters from ~/.clacky/channels/.
+# Must run after the bundled adapters so user adapters can extend or override.
+require_relative "channel/user_adapter_loader"
+Clacky::Channel::Adapters::UserAdapterLoader.load_all

data/lib/clacky/server/http_server.rb

@@ -436,8 +436,8 @@ module Clacky
         when ["GET",    "/api/billing/summary"]   then api_billing_summary(req, res)
         when ["GET",    "/api/billing/daily"]     then api_billing_daily(req, res)
         when ["GET",    "/api/billing/records"]   then api_billing_records(req, res)
-        when ["DELETE", "/api/billing/clear"]     then api_billing_clear(req, res)
-        when ["PATCH",  "/api/sessions/:id/model"] then api_switch_session_model(req, res)
+        when ["GET",    "/api/billing/sessions"]  then api_billing_sessions(req, res)
+        when ["DELETE", "/api/billing/clear"]     then api_billing_clear(req, res)        when ["PATCH",  "/api/sessions/:id/model"] then api_switch_session_model(req, res)
         when ["PATCH",  "/api/sessions/:id/working_dir"] then api_change_session_working_dir(req, res)
         else
           if method == "POST" && path.match?(%r{^/api/channels/[^/]+/send$})
@@ -481,6 +481,9 @@ module Clacky
           elsif method == "GET" && path.match?(%r{^/api/sessions/[^/]+/skills$})
             session_id = path.sub("/api/sessions/", "").sub("/skills", "")
             api_session_skills(session_id, res)
+          elsif method == "GET" && path.match?(%r{^/api/sessions/[^/]+/files$})
+            session_id = path.sub("/api/sessions/", "").sub("/files", "")
+            api_session_files(session_id, req, res)
           elsif method == "GET" && path.match?(%r{^/api/sessions/[^/]+/export$})
             session_id = path.sub("/api/sessions/", "").sub("/export", "")
             api_export_session(session_id, res)
@@ -496,6 +499,9 @@ module Clacky
           elsif method == "PATCH" && path.match?(%r{^/api/sessions/[^/]+/reasoning_effort$})
             session_id = path.sub("/api/sessions/", "").sub("/reasoning_effort", "")
             api_switch_session_reasoning_effort(session_id, req, res)
+          elsif method == "PATCH" && path.match?(%r{^/api/sessions/[^/]+/submodel$})
+            session_id = path.sub("/api/sessions/", "").sub("/submodel", "")
+            api_switch_session_submodel(session_id, req, res)
           elsif method == "POST" && path.match?(%r{^/api/sessions/[^/]+/benchmark$})
             session_id = path.sub("/api/sessions/", "").sub("/benchmark", "")
             api_benchmark_session_models(session_id, req, res)
@@ -1164,8 +1170,27 @@ module Clacky
         })
       end
 
-      # DELETE /api/billing/clear
-      # Clears billing records
+      # GET /api/billing/sessions
+      # Returns session-level billing summary
+      # Query params: period (day|week|month|year|all, default: month), model, limit
+      def api_billing_sessions(req, res)
+        require_relative "../billing/billing_store"
+
+        query = URI.decode_www_form(req.query_string.to_s).to_h
+        period = (query["period"] || "month").to_sym
+        model = query["model"]
+        limit = [(query["limit"] || "50").to_i, 200].min
+
+        store = Clacky::Billing::BillingStore.new
+        sessions = store.session_summary(period: period, model: model, limit: limit)
+
+        json_response(res, 200, {
+          sessions: sessions,
+          count: sessions.size
+        })
+      end
+
+      # DELETE /api/billing/clear      # Clears billing records
       # Query params: scope (today|all, default: today)
       def api_billing_clear(req, res)
         require_relative "../billing/billing_store"
@@ -2445,7 +2470,56 @@ module Clacky
         json_response(res, 200, { skills: skill_data })
       end
 
-      # PATCH /api/skills/:name/toggle — enable or disable a skill
+      # GET /api/sessions/:id/files?path=<relative dir>
+      # Lists one directory level inside the session's working_dir (lazy, per-layer).
+      # Path traversal outside working_dir is rejected. Noisy dirs are hidden.
+      IGNORED_FILE_ENTRIES = %w[.git .svn .hg node_modules .DS_Store .bundle vendor/bundle tmp .sass-cache].freeze
+
+      def api_session_files(session_id, req, res)
+        unless @registry.ensure(session_id)
+          return json_response(res, 404, { error: "Session not found" })
+        end
+        session = @registry.get(session_id)
+        agent   = session && session[:agent]
+        return json_response(res, 404, { error: "Session not found" }) unless agent
+
+        root = File.expand_path(agent.working_dir.to_s)
+        return json_response(res, 404, { error: "Working directory not found" }) unless Dir.exist?(root)
+
+        rel = URI.decode_www_form(req.query_string.to_s).to_h["path"].to_s
+        rel = rel.sub(%r{\A/+}, "").strip
+        target = File.expand_path(File.join(root, rel))
+
+        # Reject traversal outside the working directory.
+        unless target == root || target.start_with?("#{root}/")
+          return json_response(res, 403, { error: "Path outside working directory" })
+        end
+        return json_response(res, 404, { error: "Directory not found" }) unless Dir.exist?(target)
+
+        entries = Dir.children(target).reject { |name| IGNORED_FILE_ENTRIES.include?(name) }
+
+        items = entries.filter_map do |name|
+          full = File.join(target, name)
+          is_dir = File.directory?(full)
+          # Skip symlinks pointing outside the root, and anything unreadable.
+          next unless File.exist?(full)
+          {
+            name:  name,
+            path:  rel.empty? ? name : "#{rel}/#{name}",
+            type:  is_dir ? "dir" : "file",
+            size:  is_dir ? nil : (File.size(full) rescue nil)
+          }
+        rescue StandardError
+          nil
+        end
+
+        # Directories first, then files; both case-insensitive alphabetical.
+        items.sort_by! { |it| [it[:type] == "dir" ? 0 : 1, it[:name].downcase] }
+
+        json_response(res, 200, { root: root, path: rel, entries: items })
+      rescue StandardError => e
+        json_response(res, 500, { error: e.message })
+      end
       # Body: { enabled: true/false }
       def api_toggle_skill(name, req, res)
         body    = parse_json_body(req)
@@ -3601,6 +3675,47 @@ module Clacky
         json_response(res, 500, { error: e.message })
       end
 
+      # PATCH /api/sessions/:id/submodel
+      # Body: { "model_name": "dsk-deepseek-v4-pro" | null }
+      #
+      # Pin this session to a sub-model under its current card without
+      # touching credentials or the global @models. Pass null/empty to clear
+      # and fall back to the card default. The name must appear in the
+      # provider preset's "models" list — anything else is rejected.
+      def api_switch_session_submodel(session_id, req, res)
+        body = parse_json_body(req)
+        raw = body["model_name"]
+        model_name = raw.is_a?(String) ? raw.strip : nil
+
+        return json_response(res, 404, { error: "Session not found" }) unless @registry.ensure(session_id)
+
+        agent = nil
+        @registry.with_session(session_id) { |s| agent = s[:agent] }
+        return json_response(res, 404, { error: "Session not found" }) unless agent
+
+        if model_name && !model_name.empty?
+          info = agent.current_model_info
+          provider_id = info && Clacky::Providers.find_by_base_url(info[:base_url])
+          allowed = provider_id ? Clacky::Providers.models(provider_id) : []
+          if allowed.empty?
+            return json_response(res, 400, { error: "Current model has no provider preset; sub-model switching unavailable" })
+          end
+          unless allowed.include?(model_name)
+            return json_response(res, 400, { error: "Sub-model '#{model_name}' not listed under provider '#{provider_id}'" })
+          end
+        else
+          model_name = nil
+        end
+
+        agent.set_session_sub_model(model_name)
+        @session_manager.save(agent.to_session_data)
+        broadcast_session_update(session_id)
+
+        json_response(res, 200, { ok: true, sub_model: agent.current_model_info[:sub_model] })
+      rescue => e
+        json_response(res, 500, { error: e.message })
+      end
+
       # POST /api/sessions/:id/benchmark
       #
       # Speed-test every configured model in one shot so the user can pick the
@@ -3706,11 +3821,9 @@ module Clacky
 
         # Expand ~ to home directory
         expanded_dir = File.expand_path(new_dir)
-        
-        # Validate directory exists
-        unless Dir.exist?(expanded_dir)
-          return json_response(res, 400, { error: "Directory does not exist: #{expanded_dir}" })
-        end
+
+        # Auto-create the directory if it doesn't exist yet.
+        FileUtils.mkdir_p(expanded_dir)
 
         agent = nil
         @registry.with_session(session_id) { |s| agent = s[:agent] }
@@ -4189,12 +4302,18 @@ module Clacky
           broadcast(session_id, { type: "interrupted", session_id: session_id })
           @session_manager.save(agent.to_session_data(status: :interrupted))
         rescue => e
-          @registry.update(session_id, status: :error, error: e.message)
-          broadcast_session_update(session_id)
           # Route error through web_ui so channel subscribers (飞书/企微) receive it too.
           web_ui = nil
           @registry.with_session(session_id) { |s| web_ui = s[:ui] }
-          web_ui&.show_error(e.message)
+          code = e.is_a?(Clacky::InsufficientCreditError) ? e.error_code : nil
+          top_up_url = nil
+          if e.is_a?(Clacky::InsufficientCreditError) && e.provider_id
+            preset = Clacky::Providers::PRESETS[e.provider_id]
+            top_up_url = preset && preset["website_url"]
+          end
+          @registry.update(session_id, status: :error, error: e.message, error_code: code, top_up_url: top_up_url)
+          broadcast_session_update(session_id)
+          web_ui&.show_error(e.message, code: code, top_up_url: top_up_url)
           @session_manager.save(agent.to_session_data(status: :error, error_message: e.message))
         end
         @registry.with_session(session_id) { |s| s[:thread] = thread }
@@ -4286,7 +4405,9 @@ module Clacky
       # @param working_dir [String] working directory for the agent
       # @param permission_mode [Symbol] :confirm_all (default, human present) or
       #   :auto_approve (unattended — suppresses request_user_feedback waits)
-      def build_session(name:, working_dir:, permission_mode: :confirm_all, profile: "general", source: :manual, model_id: nil)
+      def build_session(name:, working_dir: nil, permission_mode: :confirm_all, profile: "general", source: :manual, model_id: nil)
+        working_dir ||= default_working_dir
+        FileUtils.mkdir_p(working_dir) unless Dir.exist?(working_dir)
         session_id = Clacky::SessionManager.generate_id
         @registry.create(session_id: session_id)
 

data/lib/clacky/server/scheduler.rb

@@ -223,11 +223,8 @@ module Clacky
         prompt    = read_task(task_name)
         name      = "⏰ #{schedule["name"]} #{Time.now.strftime("%H:%M")}"
 
-        working_dir = File.expand_path("~/clacky_workspace")
-        FileUtils.mkdir_p(working_dir)
-
         # Scheduled tasks run unattended — use auto_approve so request_user_feedback doesn't block.
-        session_id = @session_builder.call(name: name, working_dir: working_dir, permission_mode: :auto_approve, source: :cron)
+        session_id = @session_builder.call(name: name, permission_mode: :auto_approve, source: :cron)
 
         Clacky::Logger.info("scheduler_task_fired", task: task_name, session: session_id)