openclacky 1.5.6 → 1.5.7

data/lib/clacky/providers.rb

@@ -43,6 +43,7 @@ module Clacky
           "dsk-deepseek-v4-pro",
           "dsk-deepseek-v4-flash",
           "or-gemini-3-1-pro",
+          "or-gemini-3-6-flash",
           "or-gemini-3-5-flash"
         ],
         # Image generation models served by the openclacky platform
@@ -94,30 +95,34 @@ module Clacky
         # routes them to Vertex AI Gemini (generateContent with inline
         # audio parts). The gateway returns transcription text.
         "stt_models" => [
+          "or-stt-gemini-3-6-flash",
           "or-stt-gemini-3-5-flash",
           "or-stt-gemini-1-5-pro"
         ],
         "stt_model_aliases" => {
+          "or-stt-gemini-3-6-flash" => "Gemini 3.6 Flash STT",
           "or-stt-gemini-3-5-flash" => "Gemini 3.5 Flash STT",
           "or-stt-gemini-1-5-pro"   => "Gemini 1.5 Pro STT"
         },
-        "default_stt_model" => "or-stt-gemini-3-5-flash",
+        "default_stt_model" => "or-stt-gemini-3-6-flash",
         # Video understanding models served by the openclacky gateway, which
         # routes video frames to Gemini (generateContent with inline image
         # parts). The gateway returns analysis text.
         "video_understanding_models" => [
+          "or-gemini-3-6-flash",
           "or-gemini-3-5-flash",
           "or-gemini-3-1-pro"
         ],
         "video_understanding_model_aliases" => {
+          "or-gemini-3-6-flash" => "Gemini 3.6 Flash",
           "or-gemini-3-5-flash" => "Gemini 3.5 Flash",
           "or-gemini-3-1-pro"   => "Gemini 3.1 Pro"
         },
-        "default_video_understanding_model" => "or-gemini-3-5-flash",
+        "default_video_understanding_model" => "or-gemini-3-6-flash",
         # Default OCR sidecar — used when the primary model is text-only.
         # Candidates are derived from the provider's vision-capable models;
         # this just picks the cheap+fast default to surface in "auto" mode.
-        "default_ocr_model" => "or-gemini-3-5-flash",
+        "default_ocr_model" => "or-gemini-3-6-flash",
         # Provider-level default: the Claude family served here is vision-capable.
         "capabilities" => { "vision" => true }.freeze,
         # Model-level overrides: DeepSeek models routed through this provider
@@ -144,7 +149,7 @@ module Clacky
           "abs-claude-sonnet-4-6" => "abs-claude-haiku-4-5",
           "abs-claude-sonnet-4-5" => "abs-claude-haiku-4-5",
           "dsk-deepseek-v4-pro"   => "dsk-deepseek-v4-flash",
-          "or-gemini-3-1-pro"     => "or-gemini-3-5-flash"
+          "or-gemini-3-1-pro"     => "or-gemini-3-6-flash"
         },
         # Fallback chain: if a model is unavailable, try the next one in order.
         # Keys are primary model names; values are the fallback model to use instead.
@@ -615,7 +620,8 @@ module Clacky
       { pattern: /glm/i,           limit: 65_536 }, # GLM-5.2: 128K output ceiling; 64K ample for reasoning+answer
       { pattern: /kimi-k3/i,       limit: 65_536 }, # Kimi K3: max_completion_tokens=131072 (max 1M); 64K ample
       { pattern: /mimo-v2\.5-pro/i, limit: 65_536 }, # MiMo-V2.5-Pro: max_completion_tokens=131072; 64K ample
-      { pattern: /mimo/i,           limit: 32_768 }  # MiMo-V2.5: max_completion_tokens=32768; full default ceiling
+      { pattern: /mimo/i,           limit: 32_768 }, # MiMo-V2.5: max_completion_tokens=32768; full default ceiling
+      { pattern: /gemini/i,        limit: 65_536 }  # Gemini 3.x: 64K max output ceiling
     ].freeze
 
     class << self

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"
@@ -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).
@@ -6351,8 +6362,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 +6393,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 +6903,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 +7115,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 +7300,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 +7339,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,20 @@ 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
+    def cleanup_by_count(keep:, grouped_keep: 200)
+      non_pinned = all_sessions.reject { |s| s[:pinned] }
 
-      cron, regular = non_pinned.partition { |s| s[:source].to_s == "cron" }
+      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/progress_handle.rb

@@ -131,6 +131,7 @@ module Clacky
         @metadata      = {}
         @last_chunk_at = nil
         @monitor       = Monitor.new
+        @closed_cond   = @monitor.new_cond
       end
 
       # Start rendering. Registers with the owner (allocating an entry id
@@ -185,7 +186,10 @@ module Clacky
         snapshot = @monitor.synchronize do
           return if @unregistered
           first_close = @state == :running
-          @state = :closed if first_close
+          if first_close
+            @state = :closed
+            @closed_cond.broadcast
+          end
           {
             first_close: first_close,
             message: final_message || @message,
@@ -205,6 +209,21 @@ module Clacky
       end
       alias_method :cancel, :finish
 
+      # Close without leaving any trace: the owner removes the entry instead
+      # of committing a final frame. For work whose outcome was "nothing to
+      # report", where a lingering line is pure noise.
+      def discard
+        @monitor.synchronize do
+          return if @unregistered
+          @state = :closed
+          @closed_cond.broadcast
+        end
+
+        stop_ticker
+        @owner.unregister_progress(self, final_frame: nil)
+        @monitor.synchronize { @unregistered = true }
+      end
+
       # True while the ticker thread is alive.
       def ticker_alive?
         t = @ticker
@@ -261,8 +280,13 @@ module Clacky
           Thread.current.name = "progress-ticker-#{object_id}"
           begin
             loop do
-              sleep @tick_interval
-              break if @monitor.synchronize { @state != :running }
+              # wait, not sleep: finish/discard signals the condition so a
+              # long tick_interval never delays shutdown.
+              closed = @monitor.synchronize do
+                @closed_cond.wait(@tick_interval) if @state == :running
+                @state != :running
+              end
+              break if closed
               render_now
             end
           rescue StandardError