openclacky 1.5.12 → 1.5.13

data/lib/clacky/server/http_server.rb

@@ -19,6 +19,7 @@ require "open3"
 require_relative "session_registry"
 require_relative "project_manager"
 require_relative "git_panel"
+require_relative "dir_picker"
 require_relative "web_ui_controller"
 require_relative "model_prices"
 require_relative "scheduler"
@@ -166,6 +167,8 @@ module Clacky
     #   *    /api/*                  → JSON REST API (sessions, tasks, schedules)
     #   GET  /**                     → static files served from lib/clacky/web/ directory
     class HttpServer
+      include DirPicker
+
       WEB_ROOT = File.expand_path("../web", __dir__)
       # How long shutdown waits for each agent thread to unwind before falling
       # back to a manual session save.
@@ -658,6 +661,8 @@ module Clacky
         when ["PATCH",  "/api/config/settings"]  then api_update_settings(req, res)
         when ["POST",   "/api/config/models"] then api_add_model(req, res)
         when ["POST",   "/api/config/test"]   then api_test_config(req, res)
+        when ["POST",   "/api/config/reload"] then api_config_reload(req, res)
+        when ["POST",   "/api/access_key/reload"] then api_access_key_reload(req, res)
         when ["POST",   "/api/config/media/test"] then api_test_media_config(req, res)
         when ["GET",    "/api/config/media"]  then api_get_media_config(res)
         when ["GET",    "/api/config/ocr"]    then api_get_ocr_config(res)
@@ -796,6 +801,9 @@ module Clacky
           elsif method == "POST" && path.match?(%r{^/api/sessions/[^/]+/git/commit$})
             session_id = path[%r{^/api/sessions/([^/]+)/git/}, 1]
             api_session_git_commit(session_id, req, res)
+          elsif method == "POST" && path.match?(%r{^/api/sessions/[^/]+/git/restore$})
+            session_id = path[%r{^/api/sessions/([^/]+)/git/}, 1]
+            api_session_git_restore(session_id, req, res)
           elsif method == "GET" && path.match?(%r{^/api/sessions/[^/]+/time_machine$})
             session_id = path.sub("/api/sessions/", "").sub("/time_machine", "")
             api_session_time_machine(session_id, res)
@@ -3409,21 +3417,21 @@ module Clacky
       private def platform_usage_summary(period:, model:)
         require_relative "../billing/platform_billing"
 
-        api_key = platform_api_key
-        return nil if api_key.nil? || api_key.empty?
+        api_keys = platform_api_keys
+        return nil if api_keys.empty?
 
         real = Clacky::Billing::PlatformBilling.real_model(model) || model
-        Clacky::Billing::PlatformBilling.fetch_summary(api_key, period: period, model: real)
+        Clacky::Billing::PlatformBilling.fetch_summary_merged(api_keys, period: period, model: real)
       end
 
       private def platform_usage_daily(days:, model:)
         require_relative "../billing/platform_billing"
 
-        api_key = platform_api_key
-        return nil if api_key.nil? || api_key.empty?
+        api_keys = platform_api_keys
+        return nil if api_keys.empty?
 
         real = Clacky::Billing::PlatformBilling.real_model(model) || model
-        Clacky::Billing::PlatformBilling.fetch_daily(api_key, days: days, model: real)
+        Clacky::Billing::PlatformBilling.fetch_daily_merged(api_keys, days: days, model: real)
       end
 
       private def merge_billing_models(platform_models, local_models)
@@ -3456,14 +3464,19 @@ module Clacky
         merged.transform_values { |v| v.round(6) }
       end
 
-      private def platform_api_key
+      # All openclacky api keys in the user's model config, deduped and
+      # empty-stripped. The billing page queries the platform once per key
+      # and merges the results, so every configured account is included.
+      private def platform_api_keys
+        keys = []
         @agent_config.models.each do |m|
           next unless m.is_a?(Hash)
           next unless @agent_config.provider_id_for(m) == "openclacky"
+
           key = m["api_key"].to_s.strip
-          return key unless key.empty?
+          keys << key unless key.empty?
         end
-        nil
+        keys.uniq
       end
 
       # POST /api/ui/open_aside
@@ -3551,10 +3564,10 @@ module Clacky
         s.start_with?("127.") || s == "::ffff:127.0.0.1"
       end
 
-      # Resolve access key from CLACKY_ACCESS_KEY env var only.
+      # Resolve access key from ~/.clacky/access_key, falling back to the
+      # CLACKY_ACCESS_KEY env var.
       private def resolve_access_key
-        key = ENV.fetch("CLACKY_ACCESS_KEY", "").strip
-        key.empty? ? nil : key
+        Clacky::AccessKey.resolve
       end
 
       # Extract bearer token or query param from a WEBrick request.
@@ -3676,7 +3689,7 @@ module Clacky
         Clacky::Logger.info("[Upgrade] Official source — running: #{cmd}")
         broadcast_all(type: "upgrade_log", line: "Starting upgrade: #{cmd}\n")
 
-        output, exit_code = run_shell(cmd, timeout: 600)
+        output, exit_code = run_shell(cmd, timeout: 600, env: gem_install_env)
 
         Clacky::Logger.info("[Upgrade] exit_code=#{exit_code}")
         Clacky::Logger.info("[Upgrade] output=#{output.slice(0, 1000)}")
@@ -3734,7 +3747,7 @@ module Clacky
         broadcast_all(type: "upgrade_log", line: "Installing...\n")
         Clacky::Logger.info("[Upgrade] Running: #{cmd}")
 
-        output, exit_code = run_shell(cmd, timeout: 600)
+        output, exit_code = run_shell(cmd, timeout: 600, env: gem_install_env)
         success = exit_code&.zero? || false
 
         broadcast_all(type: "upgrade_log", line: output)
@@ -3810,6 +3823,63 @@ module Clacky
         schedule_restart
       end
 
+      # POST /api/config/reload
+      # Re-reads ~/.clacky/config.yml into the live @agent_config. Every session
+      # shares the same @models array, so a reload reaches all of them at once.
+      def api_config_reload(_req, res)
+        was_configured = @agent_config.models_configured?
+
+        unless @agent_config.reload!
+          json_response(res, 500, { ok: false, error: "Failed to reload config.yml" })
+          return
+        end
+
+        # A server that booted with an empty config never built its default
+        # session (create_default_session bails on models_configured?). Now
+        # that models exist, complete that deferred startup step.
+        if !was_configured && @agent_config.models_configured?
+          create_default_session
+        end
+
+        json_response(res, 200, {
+          ok:                true,
+          models:            @agent_config.models.size,
+          models_configured: @agent_config.models_configured?
+        })
+      end
+
+      # POST /api/access_key/reload
+      # Re-reads the access key from ~/.clacky/access_key (or CLACKY_ACCESS_KEY).
+      # Write the new key to that file first, then call this to swap it in
+      # without restarting. Pass {"key": "..."} to have the server persist the
+      # key for you, or {"generate": true} to get a freshly generated one back.
+      def api_access_key_reload(req, res)
+        body = parse_json_body(req)
+
+        if body["generate"]
+          key = Clacky::AccessKey.write(Clacky::AccessKey.generate)
+        elsif !body["key"].to_s.strip.empty?
+          key = Clacky::AccessKey.write(body["key"])
+        else
+          key = Clacky::AccessKey.resolve
+        end
+
+        @access_key = @localhost_only ? nil : key
+        # Old lockout counters were scoped to the previous key; a client that
+        # tripped them should not stay banned after a rotation.
+        @auth_failures_mutex.synchronize { @auth_failures.clear }
+
+        Clacky::Logger.info("[Auth] Access key reloaded (configured=#{!key.nil?})")
+
+        payload = { ok: true, configured: !key.nil? }
+        # Only echo the key when the server generated it — otherwise the caller
+        # already knows it, and logging/proxies shouldn't see it again.
+        payload[:access_key] = key if body["generate"]
+        json_response(res, 200, payload)
+      rescue ArgumentError => e
+        json_response(res, 400, { ok: false, error: e.message })
+      end
+
       private def schedule_restart
         Clacky::ThreadRegistry.spawn(name: "schedule-restart") do
           sleep 0.5  # Let WEBrick flush the HTTP response
@@ -3922,8 +3992,23 @@ module Clacky
       # Delegates to Terminal.run_sync which handles the idle-poll loop
       # internally (see its docs for why that's needed — this wrapper used
       # to re-implement it wrong and caused the 0.9.36 upgrade bug).
-      private def run_shell(command, timeout: 120)
-        Clacky::Tools::Terminal.run_sync(command, timeout: timeout)
+      private def run_shell(command, timeout: 120, env: nil)
+        Clacky::Tools::Terminal.run_sync(command, timeout: timeout, env: env)
+      end
+
+      # Install next to the gem the server is currently running from, bypassing
+      # any GEM_HOME hardcoded in the user's shell rc (system-Ruby users).
+      private def gem_install_env
+        spec = Gem.loaded_specs["openclacky"]
+        gem_home = if spec
+                     spec.base_dir
+                   else
+                     Gem.dir
+                   end
+        {
+          "GEM_HOME" => gem_home,
+          "GEM_PATH" => Gem.path.join(File::PATH_SEPARATOR),
+        }
       end
 
       # ── Channel API ───────────────────────────────────────────────────────────
@@ -4975,7 +5060,26 @@ module Clacky
         end
       end
 
-      # GET /api/sessions/:id/time_machine — task history for the Time Machine
+      # POST /api/sessions/:id/git/restore - body: { file: }.
+      # Discards uncommitted changes to one file, back to its HEAD state.
+      def api_session_git_restore(session_id, req, res)
+        dir = git_session_dir(session_id, res)
+        return unless dir
+
+        unless Clacky::Server::GitPanel.repo?(dir)
+          return json_response(res, 400, { error: "Not a git repository" })
+        end
+
+        body = parse_json_body(req)
+        result = Clacky::Server::GitPanel.restore(dir, file: body["file"])
+        if result[:ok]
+          json_response(res, 200, result)
+        else
+          json_response(res, 422, { error: result[:error] })
+        end
+      end
+
+      # GET /api/sessions/:id/time_machine - task history for the Time Machine
       # panel. Mirrors the CLI menu: each entry carries id, summary, status
       # (current/past/undone) and whether it branches.
       def api_session_time_machine(session_id, res)
@@ -5076,82 +5180,6 @@ module Clacky
       # 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
 
-      # Windows "special" folders under C:\Users that aren't real user profiles.
-      WINDOWS_PROFILE_DIRS = ["Public", "Default", "Default User", "All Users"].freeze
-
-      # Sidebar quick-access favorites for the directory picker (Finder-style).
-      # Translated client-side via `id`. On WSL every favorite targets the
-      # Windows profile (/mnt/<drive>/Users/<name>/...) so they match where a
-      # Windows browser actually saves files; elsewhere they stay under Dir.home.
-      private def dir_picker_places
-        home = Dir.home
-        win_home = wsl_windows_home
-        places = []
-
-        [["home", win_home || home],
-         ["desktop",   File.join(win_home || home, "Desktop")],
-         ["downloads", File.join(win_home || home, "Downloads")],
-         ["documents", File.join(win_home || home, "Documents")]].each do |id, path|
-          places << { id: id, path: path, kind: "favorite" } if Dir.exist?(path)
-        end
-
-        places
-      end
-
-      # True when running inside Windows Subsystem for Linux.
-      private def wsl?
-        return true if ENV["WSL_DISTRO_NAME"]
-        return true if File.exist?("/proc/sys/fs/binfmt_misc/WSLInterop")
-        version = begin
-          File.read("/proc/version")
-        rescue StandardError
-          ""
-        end
-        version.downcase.include?("microsoft")
-      end
-
-      # Best-effort path to the Windows user profile under WSL, or nil when it
-      # can't be determined (then callers fall back to Dir.home). Scans every
-      # mounted drive's Users dir instead of assuming the system drive is C:.
-      private def wsl_windows_home
-        return nil unless wsl?
-
-        roots = wsl_windows_users_roots
-        username = ENV["WINDOWS_USERNAME"] || ENV["USERNAME"]
-        if username && !username.empty?
-          roots.each do |root|
-            candidate = File.join(root, username)
-            return candidate if Dir.exist?(candidate)
-          end
-        end
-
-        roots.each do |root|
-          profiles = Dir.children(root).select do |name|
-            full = File.join(root, name)
-            File.directory?(full) &&
-              !WINDOWS_PROFILE_DIRS.include?(name) &&
-              !name.start_with?(".")
-          end
-          return File.join(root, profiles.first) if profiles.one?
-        end
-
-        nil
-      end
-
-      # Every mounted drive that exposes a Windows Users directory, e.g.
-      # /mnt/c/Users and /mnt/d/Users.
-      private def wsl_windows_users_roots
-        mounts = "/mnt"
-        return [] unless Dir.exist?(mounts)
-
-        roots = []
-        Dir.children(mounts).each do |drive|
-          root = File.join(mounts, drive, "Users")
-          roots << root if Dir.exist?(root)
-        end
-        roots
-      end
-
       def api_session_files(session_id, req, res)
         unless @registry.ensure(session_id)
           return json_response(res, 404, { error: "Session not found" })
@@ -5170,6 +5198,7 @@ module Clacky
 
         # Absolute mode: allow browsing outside working directory (e.g., root "/")
         if absolute_mode
+          rel = Utils::EnvironmentDetector.win_to_linux_path(rel)
           target = File.expand_path(rel.empty? ? "/" : rel)
           display_root = target
           # Normalize rel for API response
@@ -5224,7 +5253,9 @@ module Clacky
         show_hidden = query["show_hidden"] == "true"
         include_files = query["files"] == "true"
         rel   = Dir.home if rel.empty?
+        rel   = Utils::EnvironmentDetector.win_to_linux_path(rel)
         target = File.expand_path(rel.start_with?("~") ? rel.sub(/\A~/, Dir.home) : rel)
+        requested_target = target
 
         # The requested directory may not exist yet (e.g. the default
         # ~/clacky_workspace before any session created it). Instead of 404,
@@ -5251,7 +5282,7 @@ module Clacky
         end
         items.sort_by! { |it| [it[:type] == "dir" ? 0 : 1, it[:name].downcase] }
 
-        json_response(res, 200, { root: target, path: target, parent: File.dirname(target), home: Dir.home, default: default_working_dir, entries: items, places: dir_picker_places })
+        json_response(res, 200, { root: target, path: target, parent: File.dirname(target), exact: target == requested_target, home: Dir.home, default: default_working_dir, entries: items, places: dir_picker_places })
       rescue StandardError => e
         json_response(res, 500, { error: e.message })
       end
@@ -5272,7 +5303,7 @@ module Clacky
       # Body: { parent: "/abs/parent", name: "New Folder" }
       def api_dirs_mkdir(req, res)
         body   = parse_json_body(req)
-        parent = body["parent"].to_s
+        parent = Utils::EnvironmentDetector.win_to_linux_path(body["parent"].to_s)
         name   = body["name"].to_s.strip
 
         return json_response(res, 422, { error: "parent must be an absolute path" }) unless parent.start_with?("/")
@@ -5754,10 +5785,12 @@ module Clacky
       # GET /api/profile
       # Returns { ok:, user: { path, content, is_default }, soul: { ... } }
       private def api_profile_get(res)
+        soul = _profile_read_file("SOUL.md")
+        soul[:name] = _soul_name(soul[:content])
         json_response(res, 200, {
           ok:   true,
           user: _profile_read_file("USER.md"),
-          soul: _profile_read_file("SOUL.md")
+          soul: soul
         })
       end
 
@@ -5828,6 +5861,16 @@ module Clacky
         { path: "", content: "", is_default: true, error: e.message }
       end
 
+      # Extracts the AI name from a SOUL.md heading ("# 老六 — Soul"). Returns
+      # nil when the heading is absent (e.g. the built-in default soul).
+      private def _soul_name(content)
+        return nil if content.nil? || content.empty?
+        m = content.match(/^#\s*(.+?)\s*[—–-]\s*Soul\s*$/i)
+        return nil unless m
+        name = m[1].to_s.strip
+        name.empty? ? nil : name
+      end
+
       # ── Memories API (~/.clacky/memories/*.md) ───────────────────────
       #
       # Long-term memories are plain Markdown files with YAML frontmatter
@@ -6377,13 +6420,13 @@ module Clacky
       # never send "the whole list" anymore.
 
       # Normalize an incoming api_format value into one of the supported
-      # explicit formats ("anthropic-messages" / "openai-completions"), or nil
-      # for auto. Returns :invalid for unsupported values so callers can
-      # reject the request outright.
+      # explicit formats ("anthropic-messages" / "openai-completions" /
+      # "openai-responses"), or nil for auto. Returns :invalid for unsupported
+      # values so callers can reject the request outright.
       private def normalize_api_format(value)
         return nil if value.nil? || value.to_s.strip.empty?
         v = value.to_s.strip
-        return v if %w[anthropic-messages openai-completions].include?(v)
+        return v if %w[anthropic-messages openai-completions openai-responses].include?(v)
         :invalid
       end
 
@@ -7384,10 +7427,11 @@ module Clacky
       # ── Session actions ───────────────────────────────────────────────────────
 
       def handle_edit_message(session_id, content, created_at)
-        return unless @registry.exist?(session_id)
+        session = @registry.get(session_id)
+        return unless session
+        return if session[:status] == :running
 
-        agent = nil
-        @registry.with_session(session_id) { |s| agent = s[:agent] }
+        agent = session[:agent]
         return unless agent
 
         if agent.history.respond_to?(:truncate_from_created_at) && !created_at.to_s.empty?

data/lib/clacky/tools/terminal.rb

@@ -876,7 +876,8 @@ module Clacky
         end
 
         marker_token = SecureRandom.hex(8)
-        reader_thread = start_reader_thread(reader, log_io)
+        session_box = []
+        reader_thread = start_reader_thread(reader, log_io, session_box)
 
         session = SessionManager.register(
           pid: pid, command: command, cwd: cwd || Dir.pwd,
@@ -886,6 +887,7 @@ module Clacky
           mode: "shell", marker_token: marker_token,
           shell_name: shell_name
         )
+        session_box << session
 
         # Give the shell a moment to print its startup banner (zsh -l -i
         # loads a lot of stuff), then drain whatever noise it wrote so the
@@ -905,8 +907,21 @@ module Clacky
         session
       end
 
-      # Background thread: drain PTY → log file.
-      private def start_reader_thread(reader, log_io)
+      # Background thread: drain PTY → log file. It doubles as the session's
+      # death watcher: when the child exits, read_nonblock raises EIO and the
+      # thread ends up in the ensure block below. Releasing the PTY fds and
+      # forgetting the session there means a dead session's master fd is
+      # reclaimed the moment its child dies — even when the calling agent
+      # never comes back to poll or kill it, which used to leak the fd until
+      # the process hit EMFILE ("Too many open files").
+      #
+      # `session_box` is a one-element array filled by spawn_shell right
+      # after SessionManager.register (the session cannot exist before the
+      # thread starts); an empty box means registration never happened and
+      # spawn_shell itself owns the cleanup. Every close is rescue-guarded
+      # and SessionManager.forget is a plain Hash#delete, so this whole
+      # block is a no-op when the main thread's cleanup_session ran first.
+      private def start_reader_thread(reader, log_io, session_box)
         Clacky::ThreadRegistry.spawn(name: "terminal-pty-reader") do
           loop do
             break if reader.closed? || log_io.closed?
@@ -926,6 +941,15 @@ module Clacky
           end
         ensure
           log_io.close rescue nil
+          if (session = session_box[0])
+            # Flip the status first so a main thread parked in
+            # read_until_marker's poll loop notices the death immediately
+            # (its refresh() no longer finds the session in the registry).
+            session.status = "exited" unless %w[exited killed].include?(session.status)
+            session.writer.close rescue nil
+            session.reader.close rescue nil
+            SessionManager.forget(session.id)
+          end
         end
       end
 

data/lib/clacky/ui2/markdown_renderer.rb

@@ -2,6 +2,7 @@
 
 require "tty-screen"
 require_relative "theme_manager"
+require_relative "strings_cjk_patch"
 
 module Clacky
   module UI2
@@ -21,14 +22,24 @@ module Clacky
           # Get current theme colors
           theme = ThemeManager.current_theme
 
+          width = TTY::Screen.width - 4  # Leave some margin
+
           # Configure tty-markdown with custom theme and symbols
           parsed = TTY::Markdown.parse(content, 
             theme: theme_colors,
             symbols: custom_symbols,
-            width: TTY::Screen.width - 4  # Leave some margin
+            width: width
           )
 
           parsed
+        rescue IndexError => e
+          # Safety net behind strings_cjk_patch; retry uncolored if wrap still fails.
+          warn "[markdown] color render failed (#{e.class}), retrying without color" if ENV["CLACKY_DEBUG"]
+          begin
+            TTY::Markdown.parse(content, color: :never, symbols: custom_symbols, width: width)
+          rescue StandardError
+            content
+          end
         rescue StandardError => e
           warn "[markdown] render failed: #{e.class}: #{e.message}" if ENV["CLACKY_DEBUG"]
           content
@@ -59,20 +70,12 @@ module Clacky
         def theme_colors
           theme = ThemeManager.current_theme
 
-          # Map our theme colors to tty-markdown's expected format
-          # Note: theme.colors values are already arrays, so we need to flatten when adding styles
+          # tty-markdown accepts a single :header key for all header levels
+          # (h1 additionally underlines). Code block colors come from rouge.
           {
-            # Headers use info color (cyan/blue)
-            h1: Array(theme.colors[:info]) + [:bold],
-            h2: Array(theme.colors[:info]) + [:bold],
-            h3: Array(theme.colors[:info]),
-            h4: Array(theme.colors[:info]),
-            h5: Array(theme.colors[:info]),
-            h6: Array(theme.colors[:info]),
+            header: [:bright_cyan, :bold],
             # Horizontal rule - make it subtle (dim gray)
             hr: [:bright_black],
-            # Code blocks use dim color
-            code: Array(theme.colors[:thinking]),
             # Links use success color (green)
             link: Array(theme.colors[:success]),
             # Lists use default text color

data/lib/clacky/ui2/strings_cjk_patch.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "strings"
+
+# strings 0.2.1 (latest release, 2021) tracks ANSI reinsertion offsets in
+# display width (CJK chars count as 2) but applies them as String character
+# indexes via String#insert, so any colored CJK content that needs wrapping
+# raises IndexError. These methods mirror upstream with offsets tracked in
+# character count instead of display width.
+module Strings
+  module Wrap
+    module_function
+
+    def format_line(text_line, wrap_at, ansi_stack)
+      lines = []
+      line  = []
+      word  = []
+      ansi  = []
+      ansi_matched = false
+      word_length = 0
+      line_length = 0
+      word_chars = 0
+      line_chars = 0
+      char_length = 0
+      text_length = display_width(text_line)
+      total_length = 0
+
+      UnicodeUtils.each_grapheme(text_line) do |char|
+        if char == Strings::ANSI::CSI || ansi.length > 0
+          ansi << char
+          if Strings::ANSI.only_ansi?(ansi.join)
+            ansi_matched = true
+          elsif ansi_matched
+            ansi_stack << [ansi[0...-1].join, line_chars + word_chars]
+            ansi_matched = false
+
+            if ansi.last == Strings::ANSI::CSI
+              ansi = [ansi.last]
+            else
+              ansi = []
+            end
+          end
+          next if ansi.length > 0
+        end
+
+        char_length = display_width(char)
+        total_length += char_length
+        if line_length + word_length + char_length <= wrap_at
+          if char == SPACE || total_length == text_length
+            line << word.join + char
+            line_length += word_length + char_length
+            line_chars += word_chars + char.size
+            word = []
+            word_length = 0
+            word_chars = 0
+          else
+            word << char
+            word_length += char_length
+            word_chars += char.size
+          end
+          next
+        end
+
+        if char == SPACE
+          lines << insert_ansi(line.join, ansi_stack)
+          line = []
+          line_length = 0
+          line_chars = 0
+          word << char
+          word_length += char_length
+          word_chars += char.size
+        elsif word_length + char_length <= wrap_at
+          lines << insert_ansi(line.join, ansi_stack)
+          line = [word.join + char]
+          line_length = word_length + char_length
+          line_chars = word_chars + char.size
+          word = []
+          word_length = 0
+          word_chars = 0
+        else # hyphenate word - too long to fit a line
+          lines << insert_ansi(word.join, ansi_stack)
+          line_length = 0
+          line_chars = 0
+          word = [char]
+          word_length = char_length
+          word_chars = char.size
+        end
+      end
+      lines << insert_ansi(line.join, ansi_stack) unless line.empty?
+      lines << insert_ansi(word.join, ansi_stack) unless word.empty?
+      lines
+    end
+
+    def insert_ansi(string, ansi_stack = [])
+      return string if ansi_stack.empty?
+      return string if string.empty?
+
+      new_stack = []
+      output          = string.dup
+      length          = string.size
+      matched_reset   = false
+      ansi_reset      = Strings::ANSI::RESET
+
+      ansi_stack.reverse_each do |ansi|
+        pos = ansi[1]
+        # Offsets carried over from a previous (longer) line can exceed this
+        # line; such codes belong before the wrapped content.
+        pos = 0 if pos > length
+        if ansi[0] =~ /#{Regexp.quote(ansi_reset)}/
+          matched_reset = true
+          output.insert(pos, ansi_reset)
+          next
+        elsif !matched_reset # ansi without reset
+          matched_reset = false
+          new_stack << ansi # keep the ansi
+          next if pos == length
+          if output.end_with?(NEWLINE)
+            output.insert(-2, ansi_reset)
+          else
+            output.insert(-1, ansi_reset)
+          end
+        end
+
+        output.insert(pos, ansi[0])
+      end
+
+      ansi_stack.replace(new_stack)
+
+      output
+    end
+  end
+end

data/lib/clacky/ui2/themes/hacker_theme.rb

@@ -31,7 +31,7 @@ module Clacky
         COLORS = {
           # Format: [symbol_color, dark_bg_text, light_bg_text]
           user: [:bright_black, :white, :black],           # User prompt and input
-          assistant: [:bright_green, :bright_black, :bright_black], # AI response - keep green hacker style
+          assistant: [:bright_green, :bright_white, :black], # AI response
           tool_call: [:bright_cyan, :cyan, :cyan],                # Tool execution
           tool_result: [:bright_cyan, :bright_black, :bright_black], # Tool output
           tool_denied: [:bright_yellow, :yellow, :yellow],        # Denied actions

data/lib/clacky/ui2/themes/minimal_theme.rb

@@ -28,7 +28,7 @@ module Clacky
         COLORS = {
           # Format: [symbol_color, dark_bg_text, light_bg_text]
           user: [:bright_black, :bright_black, :black],           # User prompt and input
-          assistant: [:green, :bright_black, :bright_black],      # AI response
+          assistant: [:green, :bright_white, :black],           # AI response
           tool_call: [:cyan, :cyan, :cyan],                       # Tool execution
           tool_result: [:cyan, :bright_black, :bright_black],     # Tool output
           tool_denied: [:yellow, :yellow, :yellow],               # Denied actions