openclacky 1.5.6 → 1.5.8

data/lib/clacky/server/http_server.rb

@@ -113,6 +113,12 @@ module Clacky
         @events << { type: "subagent_end", session_id: @session_id }
       end
 
+      # Custom extension events recorded on messages (Agent#emit_event). Must be
+      # explicit: method_missing below would otherwise swallow them.
+      def emit(type, **data)
+        @events << { type: type, session_id: @session_id }.merge(data)
+      end
+
       # Ignore all other UI methods (progress, errors, etc.) during history replay
       def method_missing(name, *args, **kwargs); end
       def respond_to_missing?(name, include_private = false); true; end
@@ -126,6 +132,9 @@ module Clacky
     #   GET  /**                     → static files served from lib/clacky/web/ directory
     class HttpServer
       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.
+      AGENT_INTERRUPT_JOIN_SECONDS = 2
       EXCHANGE_RATE_PRIMARY_BASE_URL = "https://open.er-api.com/v6/latest"
       EXCHANGE_RATE_FALLBACK_URL = "https://api.frankfurter.app/latest"
       OSS_CDN_BASE = "https://oss.1024code.com/openclacky"
@@ -175,7 +184,7 @@ module Clacky
         - 将大目标拆解为可执行的小步骤
       MD
 
-      def initialize(host: "127.0.0.1", port: 7070, agent_config:, client_factory:, brand_test: false, sessions_dir: nil, socket: nil, master_pid: nil)
+      def initialize(host: "127.0.0.1", port: 7070, agent_config:, client_factory:, brand_test: false, sessions_dir: nil, projects_file: nil, socket: nil, master_pid: nil)
         @host           = host
         @port           = port
         @agent_config   = agent_config
@@ -188,7 +197,7 @@ module Clacky
         @restart_script = File.expand_path($0)
         @restart_argv   = ARGV.dup
         @session_manager = Clacky::SessionManager.new(sessions_dir: sessions_dir)
-        @project_manager = Clacky::Server::ProjectManager.new
+        @project_manager = Clacky::Server::ProjectManager.new(projects_file: projects_file)
         @registry        = SessionRegistry.new(
           session_manager:  @session_manager,
           session_restorer: method(:build_session_from_data),
@@ -791,6 +800,9 @@ module Clacky
           elsif method == "PATCH" && path.match?(%r{^/api/projects/[^/]+$})
             project_id = path.sub("/api/projects/", "")
             api_update_project(project_id, req, res)
+          elsif method == "DELETE" && path.match?(%r{^/api/projects/[^/]+/sessions$})
+            project_id = path.sub("/api/projects/", "").sub("/sessions", "")
+            api_delete_project_sessions(project_id, res)
           elsif method == "DELETE" && path.match?(%r{^/api/projects/[^/]+$})
             project_id = path.sub("/api/projects/", "")
             api_delete_project(project_id, res)
@@ -810,21 +822,20 @@ module Clacky
         q_scope      = query["q_scope"].to_s.strip.then { |v| %w[name content].include?(v) ? v : "name" }
         date         = query["date"].to_s.strip.then    { |v| v.empty? ? nil : v }
         type         = query["type"].to_s.strip.then    { |v| v.empty? ? nil : v }
-        exclude_type = query["exclude_type"].to_s.strip.then { |v| v.empty? ? nil : v }
+        exclude_type = query["exclude_type"].to_s.split(",").map(&:strip).reject(&:empty?).then { |v| v.empty? ? nil : v }
         # Backward-compat: ?source=<x> and ?profile=coding → type
         type ||= query["profile"].to_s.strip.then { |v| v.empty? ? nil : v }
         type ||= query["source"].to_s.strip.then  { |v| v.empty? ? nil : v }
 
-        sessions = @registry.list(limit: limit + 1, before: before, q: q, q_scope: q_scope, date: date, type: type, exclude_type: exclude_type)
+        sessions = @registry.list(limit: limit + 1, before: before, q: q, q_scope: q_scope, date: date, type: type, exclude_type: exclude_type, exclude_project: !!type)
 
         pinned_part, non_pinned_part = sessions.partition { |s| s[:pinned] }
         has_more = non_pinned_part.size > limit
         non_pinned_part = non_pinned_part.first(limit)
         sessions = pinned_part + non_pinned_part
 
-        stats = @registry.cron_stats
         json_response(res, 200, { sessions: sessions, has_more: has_more,
-                                  cron_count: stats[:count], latest_cron_updated_at: stats[:latest_updated_at] })
+                                  groups: @registry.group_stats_all })
       end
 
       # GET /api/sessions/:id — fetch a single session by id (memory + disk merged).
@@ -1829,6 +1840,9 @@ module Clacky
             requested_model: state["requested_model"],
             configured: state["configured"]
           }
+          if entry && entry["base_url"] && state["source"] != "custom"
+            out[t][:saved_custom] = { model: entry["model"], base_url: entry["base_url"] }
+          end
         end
 
         # Surface what the current default model can offer, even when the
@@ -1938,50 +1952,78 @@ module Clacky
       end
 
       def api_update_media_config(kind, req, res)
-        body = parse_json_body(req) || {}
+        update_sidecar_config(res, kind, parse_json_body(req) || {})
+      end
+
+      private def update_sidecar_config(res, kind, body)
         source = body["source"].to_s
         unless %w[off auto custom].include?(source)
           return json_response(res, 422, { error: "invalid source" })
         end
 
-        @agent_config.models.reject! { |m| m["type"] == kind }
+        existing = @agent_config.models.find { |m| m["type"] == kind }
 
         case source
         when "off"
-          @agent_config.models << {
-            "id"       => SecureRandom.uuid,
-            "type"     => kind,
-            "disabled" => true
-          }
-        when "auto"
-          override = body["model"].to_s.strip
-          unless override.empty?
+          if existing
+            existing["mode"] = "off"
+          else
             @agent_config.models << {
-              "id"    => SecureRandom.uuid,
-              "type"  => kind,
-              "model" => override
+              "id"   => SecureRandom.uuid,
+              "type" => kind,
+              "mode" => "off"
             }
           end
+        when "auto"
+          override = body["model"].to_s.strip
+          if existing
+            existing.delete("disabled")
+            existing["mode"] = "auto"
+            existing["model"] = override unless override.empty?
+          else
+            unless override.empty?
+              @agent_config.models << {
+                "id"    => SecureRandom.uuid,
+                "type"  => kind,
+                "mode"  => "auto",
+                "model" => override
+              }
+            end
+          end
         when "custom"
           model    = body["model"].to_s.strip
           base_url = body["base_url"].to_s.strip
           api_key  = body["api_key"].to_s
-          if model.empty? || base_url.empty? || api_key.empty? || api_key.include?("****")
+          if api_key.empty? || api_key.include?("****")
+            api_key = existing ? existing["api_key"].to_s : ""
+          end
+          if model.empty? || base_url.empty? || api_key.empty?
             return json_response(res, 422, { error: "model, base_url, api_key are required" })
           end
 
-          @agent_config.models << {
-            "id"               => SecureRandom.uuid,
-            "model"            => model,
-            "base_url"         => base_url,
-            "api_key"          => api_key,
-            "anthropic_format" => body["anthropic_format"] || false,
-            "type"             => kind
-          }
+          if existing
+            existing["model"]            = model
+            existing["base_url"]         = base_url
+            existing["api_key"]          = api_key
+            existing["anthropic_format"] = body["anthropic_format"] || false
+            existing["mode"]             = "custom"
+            existing.delete("disabled")
+          else
+            @agent_config.models << {
+              "id"               => SecureRandom.uuid,
+              "model"            => model,
+              "base_url"         => base_url,
+              "api_key"          => api_key,
+              "anthropic_format" => body["anthropic_format"] || false,
+              "type"             => kind,
+              "mode"             => "custom"
+            }
+          end
         end
 
         @agent_config.save
-        json_response(res, 200, { ok: true, state: @agent_config.media_state(kind) })
+        state = kind == "ocr" ? @agent_config.ocr_state : @agent_config.media_state(kind)
+        json_response(res, 200, { ok: true, state: state })
       rescue => e
         json_response(res, 422, { error: e.message })
       end
@@ -2005,6 +2047,9 @@ module Clacky
           configured:     state["configured"],
           primary:        state["primary"] || false
         }
+        if entry && entry["base_url"] && state["source"] != "custom"
+          out[:saved_custom] = { model: entry["model"], base_url: entry["base_url"] }
+        end
 
         # Auto-mode preview: surface what the OCR sidecar *would* be if the
         # user flipped to "auto" — derived from the same provider as the
@@ -2026,58 +2071,8 @@ module Clacky
       # PATCH /api/config/ocr
       # Body: { source: "off"|"auto"|"custom", model?, base_url?, api_key?,
       #         anthropic_format? }
-      # Mirrors api_update_media_config but for the single "ocr" type.
       def api_update_ocr_config(req, res)
-        body = parse_json_body(req) || {}
-        source = body["source"].to_s
-        unless %w[off auto custom].include?(source)
-          return json_response(res, 422, { error: "invalid source" })
-        end
-
-        @agent_config.models.reject! { |m| m["type"] == "ocr" }
-
-        case source
-        when "off"
-          @agent_config.models << {
-            "id"       => SecureRandom.uuid,
-            "type"     => "ocr",
-            "disabled" => true
-          }
-        when "auto"
-          override = body["model"].to_s.strip
-          unless override.empty?
-            @agent_config.models << {
-              "id"    => SecureRandom.uuid,
-              "type"  => "ocr",
-              "model" => override
-            }
-          end
-        when "custom"
-          model    = body["model"].to_s.strip
-          base_url = body["base_url"].to_s.strip
-          api_key  = body["api_key"].to_s
-          if api_key.include?("****")
-            existing = @agent_config.models.find { |m| m["type"] == "ocr" && m["api_key"] }
-            api_key = existing ? existing["api_key"].to_s : ""
-          end
-          if model.empty? || base_url.empty? || api_key.empty?
-            return json_response(res, 422, { error: "model, base_url, api_key are required" })
-          end
-
-          @agent_config.models << {
-            "id"               => SecureRandom.uuid,
-            "model"            => model,
-            "base_url"         => base_url,
-            "api_key"          => api_key,
-            "anthropic_format" => body["anthropic_format"] || false,
-            "type"             => "ocr"
-          }
-        end
-
-        @agent_config.save
-        json_response(res, 200, { ok: true, state: @agent_config.ocr_state })
-      rescue => e
-        json_response(res, 422, { error: e.message })
+        update_sidecar_config(res, "ocr", parse_json_body(req) || {})
       end
 
       # POST /api/config/ocr/test
@@ -6351,8 +6346,25 @@ module Clacky
         return json_response(res, 404, { error: "Project not found" }) unless @project_manager.find(project_id)
 
         @project_manager.delete(project_id)
+        _delete_project_sessions(project_id)
+
+        json_response(res, 200, { ok: true })
+      rescue => e
+        json_response(res, 500, { error: e.message })
+      end
+
+      # DELETE /api/projects/:id/sessions - delete all sessions in a project but keep the project
+      def api_delete_project_sessions(project_id, res)
+        return json_response(res, 404, { error: "Project not found" }) unless @project_manager.find(project_id)
 
-        # Soft-delete all sessions that belonged to this project.
+        deleted = _delete_project_sessions(project_id)
+        json_response(res, 200, { ok: true, deleted: deleted })
+      rescue => e
+        json_response(res, 500, { error: e.message })
+      end
+
+      private def _delete_project_sessions(project_id)
+        deleted = 0
         @session_manager.all_sessions.each do |session_data|
           next unless session_data[:project_id].to_s == project_id
 
@@ -6365,11 +6377,9 @@ module Clacky
 
           broadcast(sid, { type: "session_deleted", session_id: sid })
           unsubscribe_all(sid)
+          deleted += 1
         end
-
-        json_response(res, 200, { ok: true })
-      rescue => e
-        json_response(res, 500, { error: e.message })
+        deleted
       end
 
       # PATCH /api/sessions/:id/project — move a session into or out of a project
@@ -6877,28 +6887,23 @@ module Clacky
           interrupt_session(session_id)
 
         when "list_sessions"
-          stats    = @registry.cron_stats
-          page     = @registry.list(limit: 11, exclude_type: "cron", exclude_project: true)
+          groups   = @registry.group_stats_all
+          page     = @registry.list(limit: 11, exclude_type: SessionManager::GROUPED_SOURCES, exclude_project: true)
           has_more = page.size > 10
           all_sessions = page.first(10)
           projects = @project_manager.all
-          # Include ALL sessions that belong to any project, regardless of the
-          # 15-item pagination limit.  We merge them into the same `sessions`
-          # array; the client deduplicates by id in `setAll`.
           if projects.any?
             project_ids = projects.map { |p| p[:id] }
             project_sessions = project_ids.flat_map do |pid|
-              @registry.list(project_id: pid, exclude_type: "cron")
+              @registry.list(project_id: pid)
             end
             # Deduplicate: project sessions that are already in the first page
             # will be replaced by the enriched version from `all_sessions`.
             paged_ids = all_sessions.map { |s| s[:id] }.to_set
-            extra_project_sessions = project_sessions.reject { |s| paged_ids.include?(s[:id]) }
-            all_sessions = all_sessions + extra_project_sessions
+            all_sessions += project_sessions.reject { |s| paged_ids.include?(s[:id]) }
           end
           conn.send_json(type: "session_list", sessions: all_sessions, has_more: has_more,
-                         cron_count: stats[:count], latest_cron_updated_at: stats[:latest_updated_at],
-                         projects: projects)
+                         groups: groups, projects: projects)
 
         when "run_task"
           # Client sends this after subscribing to guarantee it's ready to receive
@@ -7094,7 +7099,7 @@ module Clacky
           rescue => e
             Clacky::Logger.error("[shutdown] interrupt failed for session=#{id}: #{e.message}")
           end
-          thread.join(2)
+          thread.join(AGENT_INTERRUPT_JOIN_SECONDS)
           @session_manager.save(agent.to_session_data(status: :interrupted, updated_at: Time.now))
         end
       end
@@ -7279,7 +7284,7 @@ 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: nil, permission_mode: :confirm_all, profile: "general", source: :manual, model_id: nil, hidden: false)
+      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
@@ -7318,7 +7323,6 @@ module Clacky
         agent = Clacky::Agent.new(client, config, working_dir: working_dir, ui: ui, profile: profile,
                                   session_id: session_id, source: source)
         agent.rename(name) unless name.nil? || name.empty?
-        agent.hidden = hidden
         idle_timer = build_idle_timer(session_id, agent)
 
         @registry.with_session(session_id) do |s|

data/lib/clacky/server/session_registry.rb

@@ -203,7 +203,7 @@ module Clacky
       #   [ ...all_pinned_matching (newest-first), ...non_pinned (newest-first, limited) ]
       #
       # source and profile are orthogonal — either can be nil independently.
-      def list(limit: nil, before: nil, q: nil, q_scope: "name", date: nil, type: nil, exclude_type: nil, include_pinned: true, project_id: nil, exclude_project: false, include_hidden: false)
+      def list(limit: nil, before: nil, q: nil, q_scope: "name", date: nil, type: nil, exclude_type: nil, include_pinned: true, project_id: nil, exclude_project: false)
         return [] unless @session_manager
 
         live = @mutex.synchronize do
@@ -228,10 +228,6 @@ module Clacky
 
         all = @session_manager.all_sessions  # already sorted newest-first
 
-        # Hidden sessions (extension-managed) are excluded from the list by
-        # default; callers that need them pass include_hidden: true.
-        all = all.reject { |s| s[:hidden] } unless include_hidden
-
         # ── type filter (replaces old source/profile split) ──────────────────
         # type=coding  → agent_profile == "coding"
         # type=manual/cron/channel/setup → source match (profile=general implied)
@@ -412,18 +408,18 @@ module Clacky
 
       public
 
-      # Count all cron sessions on disk (not filtered by pagination).
-      def cron_count
-        return 0 unless @session_manager
-        @session_manager.all_sessions.count { |s| s_source(s) == "cron" }
+      # Count + latest updated_at for sessions of a given source, excluding
+      # those assigned to a project (they show in the project section instead).
+      def group_stats(source)
+        return { count: 0, latest_updated_at: nil } unless @session_manager
+        group_all = @session_manager.all_sessions.select { |s| s_source(s) == source && s[:project_id].to_s.strip == "" }
+        latest = group_all.map { |s| s[:updated_at] || s[:created_at] }.compact.max
+        { count: group_all.size, latest_updated_at: latest }
       end
 
-      # Count + latest updated_at for cron sessions (used by sidebar virtual entry).
-      def cron_stats
-        return { count: 0, latest_updated_at: nil } unless @session_manager
-        cron_all = @session_manager.all_sessions.select { |s| s_source(s) == "cron" }
-        latest = cron_all.map { |s| s[:updated_at] || s[:created_at] }.compact.max
-        { count: cron_all.size, latest_updated_at: latest }
+      # Stats for every folded sidebar group, keyed by source.
+      def group_stats_all
+        SessionManager::GROUPED_SOURCES.to_h { |source| [source, group_stats(source)] }
       end
 
       # Delete a session from registry (and interrupt its thread).

data/lib/clacky/server/web_ui_controller.rb

@@ -221,7 +221,7 @@ module Clacky
 
       # === Phase grouping ===
 
-      def phase_start(kind:, label: nil)
+      def phase_start(kind:, label: nil, concurrent: false)
         pid = SecureRandom.uuid
         Thread.current[:clacky_phase_id] = pid
         # Emit without auto-injection (the start event itself defines the phase)

data/lib/clacky/session_manager.rb

@@ -9,6 +9,7 @@ require "set"
 module Clacky
   class SessionManager
     SESSIONS_DIR = File.join(Dir.home, ".clacky", "sessions")
+    GROUPED_SOURCES = %w[cron ext].freeze
 
     # Generate a new unique session ID (16-char hex string).
     # This is the single authoritative source for session IDs — all components
@@ -35,7 +36,7 @@ module Clacky
 
       # Keep only the most recent 200 sessions (best-effort, never block save)
       begin
-        cleanup_by_count(keep: 200, keep_cron: 200)
+        cleanup_by_count(keep: 200, grouped_keep: 200)
         cleanup_trash(days: 8)
       rescue Exception # rubocop:disable Lint/RescueException
         # Cleanup is non-critical; swallow all errors (including AgentInterrupted)
@@ -65,7 +66,6 @@ module Clacky
       forked[:created_at]  = Time.now.iso8601
       forked[:updated_at]  = Time.now.iso8601
       forked[:pinned]      = false
-      forked[:hidden]      = false
       forked[:name]        = "#{original[:name] || "Unnamed session"} (copy)"
       forked[:stats] = (original[:stats] || {}).merge(
         total_tasks: 0, total_iterations: 0, total_cost_usd: 0.0,
@@ -330,18 +330,27 @@ module Clacky
       deleted
     end
 
-    # Keep only the most recent N non-pinned, non-hidden sessions by created_at;
-    # the rest are soft-deleted (moved to the session trash, recoverable). Pinned
-    # and hidden sessions are never deleted and do not count toward the cap.
+    # Keep only the most recent N non-pinned sessions by created_at; the rest
+    # are soft-deleted (moved to the session trash, recoverable). Pinned
+    # sessions are never deleted and do not count toward the cap.
     # Returns count of soft-deleted sessions.
-    def cleanup_by_count(keep:, keep_cron: 200)
-      non_pinned = all_sessions.reject { |s| s[:pinned] || s[:hidden] } # already sorted newest-first
-
-      cron, regular = non_pinned.partition { |s| s[:source].to_s == "cron" }
+    def cleanup_by_count(keep:, grouped_keep: 200)
+      # Fast path: if total session files can't exceed any single group's cap,
+      # skip the expensive all_sessions() full-scan (read + JSON.parse every file).
+      # min() is correct because groups are mutually exclusive — any single
+      # group's count ≤ non_pinned ≤ file_count ≤ min(keep, grouped_keep).
+      file_count = Dir.glob(File.join(@sessions_dir, "*.json")).size
+      return 0 if file_count <= [keep, grouped_keep].min
+
+      non_pinned = all_sessions.reject { |s| s[:pinned] }
+
+      groups = non_pinned.group_by do |s|
+        (s[:project_id] || !GROUPED_SOURCES.include?(s[:source].to_s)) ? "regular" : s[:source].to_s
+      end
 
-      victims = []
-      victims += regular[keep..] if regular.size > keep
-      victims += cron[keep_cron..] if cron.size > keep_cron
+      victims = groups.flat_map do |source, sessions|
+        sessions[(source == "regular" ? keep : grouped_keep)..] || []
+      end
 
       victims.each { |session| soft_delete(session[:session_id]) }
       victims.size

data/lib/clacky/shell_hook_loader.rb

@@ -48,6 +48,10 @@ module Clacky
     DEFAULT_TIMEOUT         = 10
     REWRITE_DEFAULT_TIMEOUT = 60
     DENY_EXIT_CODE          = 2
+    # Grace period for a SIGTERM'd hook to exit before the group is SIGKILL'd,
+    # and for the stream readers to hit EOF afterwards.
+    KILL_GRACE_SECONDS      = 1
+    DRAIN_JOIN_SECONDS      = 2
 
     Result = Struct.new(:registered, :skipped, keyword_init: true)
 
@@ -165,15 +169,17 @@ module Clacky
       resolved = resolve_command(spec, result)
       return unless resolved
       name, command = resolved
-      timeout = (spec["timeout"] || DEFAULT_TIMEOUT).to_i
+      timeout = (spec["timeout"] || DEFAULT_TIMEOUT).to_f
 
       unless HookManager::HOOK_EVENTS.include?(event)
         result.skipped << [name, "unknown event: #{event}"]
         return
       end
 
+      # HookManager appends the owning agent as a trailing arg; shell hooks
+      # serialize their args to JSON, so drop it before building the payload.
       hook_manager.add(event) do |*args|
-        run_command(event, command, timeout, args)
+        run_command(event, command, timeout, args[0..-2])
       end
       result.registered << [event, name]
     end
@@ -183,7 +189,7 @@ module Clacky
       resolved = resolve_command(spec, result)
       return unless resolved
       name, command = resolved
-      timeout = (spec["timeout"] || REWRITE_DEFAULT_TIMEOUT).to_i
+      timeout = (spec["timeout"] || REWRITE_DEFAULT_TIMEOUT).to_f
       matcher = spec["matcher"]
 
       hook_manager.add(:before_tool_use) do |call|
@@ -245,20 +251,20 @@ module Clacky
           status = wait_thr.value
           # Child exited; drain the readers (bounded join — a grandchild
           # holding the pipe fd can keep them from EOF; see drain_stream).
-          out_reader.join(2)
-          err_reader.join(2)
+          out_reader.join(DRAIN_JOIN_SECONDS)
+          err_reader.join(DRAIN_JOIN_SECONDS)
         else
           # SIGTERM, then SIGKILL the whole group if it won't die. popen3's
           # ensure joins wait_thr without a timeout, so the child MUST be dead
           # before we leave the block — a hook that traps/ignores TERM can't be
           # allowed to hang here.
           Process.kill("TERM", -pgid) rescue nil
-          unless wait_thr.join(1)
+          unless wait_thr.join(KILL_GRACE_SECONDS)
             Process.kill("KILL", -pgid) rescue nil
             wait_thr.join
           end
-          out_reader.join(1)
-          err_reader.join(1)
+          out_reader.join(KILL_GRACE_SECONDS)
+          err_reader.join(KILL_GRACE_SECONDS)
           writer.kill rescue nil
           raise Timeout::Error
         end

data/lib/clacky/tools/invoke_skill.rb

@@ -28,8 +28,9 @@ module Clacky
       # @param task [String] Task description to pass to the skill
       # @param agent [Clacky::Agent] Agent instance (injected)
       # @param skill_loader [Clacky::SkillLoader] Skill loader instance (injected)
+      # @param tool_call_id [String, nil] This call's id (injected), used to key the subagent transcript
       # @return [Hash] Result of skill execution
-      def execute(skill_name:, task:, agent: nil, skill_loader: nil, working_dir: nil)
+      def execute(skill_name:, task:, agent: nil, skill_loader: nil, working_dir: nil, tool_call_id: nil)
         # Validate injected dependencies
         return { error: "Agent context is required" } unless agent
         return { error: "Skill loader is required" } unless skill_loader
@@ -44,7 +45,7 @@ module Clacky
         # have triggered this skill explicitly via a slash command (/skill-name).
         if skill.fork_agent?
           # Execute in isolated subagent
-          result = agent.send(:execute_skill_with_subagent, skill, task)
+          result = agent.send(:execute_skill_with_subagent, skill, task, tool_call_id: tool_call_id)
           {
             message: "Skill '#{skill_name}' executed in subagent",
             result: result,

data/lib/clacky/tools/terminal.rb

@@ -132,6 +132,13 @@ module Clacky
       BACKGROUND_COLLECT_SECONDS = 2
       # Sentinel: when passed as idle_ms, disables idle early-return.
       DISABLED_IDLE_MS = 10_000_000
+      # Gap between log-file polls while waiting for a command's end marker.
+      MARKER_POLL_SECONDS = 0.05
+      # A freshly spawned login shell prints its banner asynchronously; wait
+      # this long before draining so the marker install doesn't interleave.
+      SHELL_BANNER_SETTLE_SECONDS = 0.2
+      # Upper bound on draining that banner once it starts arriving.
+      SHELL_BANNER_DRAIN_SECONDS = 2.5
 
       # Commands that we know take a long time and produce bursty output
       # (quiet gaps between test files, compile phases, download batches,
@@ -213,7 +220,7 @@ module Clacky
           idle_ms ||= DISABLED_IDLE_MS
         end
 
-        timeout = (timeout || DEFAULT_TIMEOUT).to_i
+        timeout = (timeout || DEFAULT_TIMEOUT).to_f
         idle_ms = (idle_ms || DEFAULT_IDLE_MS).to_i
         cwd ||= working_dir
 
@@ -875,8 +882,8 @@ module Clacky
         # 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
         # marker install doesn't collide with it.
-        sleep 0.2
-        drain_any(session, timeout: 2.5)
+        sleep SHELL_BANNER_SETTLE_SECONDS
+        drain_any(session, timeout: SHELL_BANNER_DRAIN_SECONDS)
         install_marker(session)
         _before, _code, state = read_until_marker(session, timeout: 10, idle_ms: DISABLED_IDLE_MS)
         unless state == :matched
@@ -1299,7 +1306,7 @@ module Clacky
             flush_stream.call("", force_partial: true) unless stream_pending.empty?
             return ["", nil, :timeout]
           end
-          sleep 0.05
+          sleep MARKER_POLL_SECONDS
         end
       end
 

data/lib/clacky/ui2/components/inline_input.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "tty-screen"
 require_relative "../line_editor"
 
 module Clacky

data/lib/clacky/ui2/components/input_area.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "pastel"
+require "tty-screen"
 require "tempfile"
 require_relative "../theme_manager"
 require_relative "../line_editor"

data/lib/clacky/ui2/components/modal_component.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'io/console'
-require 'tty-prompt'
 require_relative 'base_component'
 
 module Clacky

data/lib/clacky/ui2/components/todo_area.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "pastel"
+require "tty-screen"
 
 module Clacky
   module UI2

data/lib/clacky/ui2/line_editor.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "pastel"
+require "tty-screen"
 
 module Clacky
   module UI2