openclacky 1.3.5 → 1.3.6

data/lib/clacky/server/http_server.rb

@@ -15,6 +15,7 @@ require "securerandom"
 require "timeout"
 require "yaml"
 require "date"
+require "open3"
 require_relative "session_registry"
 require_relative "git_panel"
 require_relative "web_ui_controller"
@@ -468,8 +469,8 @@ module Clacky
           30
         elsif path == "/api/media/video/understand"
           60
-        elsif path.start_with?("/api/backup/download") || path == "/api/backup/run"
-          # Building a tar.gz of ~/.clacky (with session history) can take a while.
+        elsif path.start_with?("/api/backup/download") || path == "/api/backup/run" || path == "/api/backup/restore"
+          # Building/extracting a tar.gz of ~/.clacky can take a while.
           120
         else
           10
@@ -525,6 +526,8 @@ module Clacky
         when ["GET",    "/api/backup/status"]     then api_backup_status(res)
         when ["POST",   "/api/backup/run"]        then api_backup_run(res)
         when ["GET",    "/api/backup/download"]   then api_backup_download(res)
+        when ["POST",   "/api/backup/restore"]    then api_backup_restore(req, res)
+        when ["POST",   "/api/backup/open-folder"] then api_backup_open_folder(res)
         when ["PATCH",  "/api/backup/config"]     then api_backup_config(req, res)
         when ["POST",   "/api/telemetry"]        then api_telemetry(req, res)
         when ["POST",   "/api/onboard/complete"]  then api_onboard_complete(req, res)
@@ -736,30 +739,28 @@ module Clacky
       # ── REST API ──────────────────────────────────────────────────────────────
 
       def api_list_sessions(req, res)
-        query   = URI.decode_www_form(req.query_string.to_s).to_h
-        limit   = [query["limit"].to_i.then { |n| n > 0 ? n : 20 }, 50].min
-        before  = query["before"].to_s.strip.then  { |v| v.empty? ? nil : v }
-        q       = query["q"].to_s.strip.then       { |v| v.empty? ? nil : v }
-        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 }
+        query        = URI.decode_www_form(req.query_string.to_s).to_h
+        limit        = [query["limit"].to_i.then { |n| n > 0 ? n : 20 }, 50].min
+        before       = query["before"].to_s.strip.then  { |v| v.empty? ? nil : v }
+        q            = query["q"].to_s.strip.then       { |v| v.empty? ? nil : v }
+        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 }
         # 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 }
 
-        # Fetch one extra NON-PINNED row to detect has_more without a separate count query.
-        # `registry.list` always returns ALL matching pinned rows first (on the
-        # first page; `before` == nil), followed by non-pinned rows up to `limit+1`.
-        # So has_more is determined by whether the non-pinned section overflowed.
-        sessions = @registry.list(limit: limit + 1, before: before, q: q, q_scope: q_scope, date: date, type: type)
+        sessions = @registry.list(limit: limit + 1, before: before, q: q, q_scope: q_scope, date: date, type: type, exclude_type: exclude_type)
 
-        # Split pinned vs non-pinned to apply has_more only to the non-pinned tail.
         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
 
-        json_response(res, 200, { sessions: sessions, has_more: has_more, cron_count: @registry.cron_count })
+        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] })
       end
 
       # GET /api/sessions/:id — fetch a single session by id (memory + disk merged).
@@ -4876,6 +4877,68 @@ module Clacky
         })
       end
 
+      # POST /api/backup/restore — accept a tar.gz upload, extract over ~/.clacky, hot-restart
+      def api_backup_restore(req, res)
+        body = req.body.to_s
+        return json_response(res, 400, { error: "Empty body" }) if body.empty?
+
+        clacky_dir = File.expand_path("~/.clacky")
+        stamp      = Time.now.strftime("%Y%m%d-%H%M%S")
+        tmp_archive = File.join(Dir.tmpdir, "clacky-restore-#{stamp}.tar.gz")
+        tmp_backup  = File.join(Dir.tmpdir, "clacky-pre-restore-#{stamp}")
+
+        File.binwrite(tmp_archive, body)
+
+        FileUtils.cp_r(clacky_dir, tmp_backup)
+
+        result = system("tar", "-xzf", tmp_archive, "-C", clacky_dir)
+        unless result
+          FileUtils.rm_rf(clacky_dir)
+          FileUtils.cp_r(tmp_backup, clacky_dir)
+          return json_response(res, 500, { error: "Failed to extract archive" })
+        end
+
+        json_response(res, 200, { ok: true })
+
+        Thread.new do
+          sleep 0.5
+          if @master_pid
+            begin
+              Process.kill("USR1", @master_pid)
+            rescue Errno::ESRCH
+              standalone_exec_restart
+            end
+          else
+            standalone_exec_restart
+          end
+        end
+      rescue => e
+        json_response(res, 500, { ok: false, error: e.message })
+      ensure
+        FileUtils.rm_f(tmp_archive) if tmp_archive
+        FileUtils.rm_rf(tmp_backup) if tmp_backup && Dir.exist?(tmp_backup)
+      end
+
+      # POST /api/backup/open-folder — open the backup destination in Finder/Explorer
+      def api_backup_open_folder(res)
+        dest = BackupManager.status["dest_dir"]
+        FileUtils.mkdir_p(dest)
+        host_os = RbConfig::CONFIG["host_os"]
+        if host_os =~ /darwin/
+          system("open", dest)
+        elsif host_os =~ /linux/
+          if File.exist?("/proc/version") && File.read("/proc/version").downcase.include?("microsoft")
+            windows_path, = Open3.capture2("wslpath", "-w", dest)
+            system("explorer.exe", windows_path.strip) unless windows_path.strip.empty?
+          else
+            system("xdg-open", dest)
+          end
+        end
+        json_response(res, 200, { ok: true, dest_dir: dest })
+      rescue => e
+        json_response(res, 500, { ok: false, error: e.message })
+      end
+
       # Resolve the AgentConfig for a given session, falling back to nil when
       # the session isn't live so callers can use the global config instead.
       def config_for_session(session_id)
@@ -5722,12 +5785,12 @@ module Clacky
           interrupt_session(session_id)
 
         when "list_sessions"
-          # Initial load: newest 20 sessions regardless of source/profile.
-          # Single unified query — frontend shows all in one time-sorted list.
-          page = @registry.list(limit: 21)
+          stats = @registry.cron_stats
+          page = @registry.list(limit: 21, exclude_type: "cron")
           has_more = page.size > 20
           all_sessions = page.first(20)
-          conn.send_json(type: "session_list", sessions: all_sessions, has_more: has_more, cron_count: @registry.cron_count)
+          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])
 
         when "run_task"
           # Client sends this after subscribing to guarantee it's ready to receive
@@ -5822,112 +5885,30 @@ module Clacky
 
       # Interrupt a running agent session.
       #
-      # Thread#raise alone is not reliable enough in practice — it's
-      # best-effort against blocked syscalls (socket writes, OpenSSL read,
-      # ConditionVariable#wait with a held mutex) and we've seen sessions
-      # that stay "running" forever even after multiple interrupt attempts.
-      #
-      # Strategy: three-tier escalation in a background watchdog Thread so
-      # the HTTP handler returns immediately.
-      #
-      #   Tier 1 (t=0): Thread#raise(AgentInterrupted).
-      #                 Unblocks most pure-Ruby waits and Faraday reads.
-      #                 Handles the common case.
-      #   Tier 2 (t=3): force-close this session's WebSocket connections
-      #                 so any send_raw stuck on socket write wakes up.
-      #                 Try Thread#raise again (idempotent).
-      #   Tier 3 (t=8): Thread#kill — last resort. Leaks any held
-      #                 resources but frees the session so the user can
-      #                 move on.
+      # Thread#raise is best-effort: it unblocks most pure-Ruby waits and
+      # Faraday reads, but can't reach a thread stuck in a C-extension syscall
+      # until that syscall returns. We raise once and return immediately.
       #
-      # Each transition is logged so that when users report "stuck
-      # sessions" we can see in the log whether tier 2/3 ever had to
-      # fire — that's our signal to dig deeper on the underlying block.
+      # Correctness of the *takeover* does not depend on the old thread dying
+      # promptly: each new task claims a fresh epoch (see run_agent_task), and
+      # any status write or UI broadcast from a superseded thread is fenced off
+      # by that epoch. A stale thread that lingers in a syscall is harmless — it
+      # self-terminates at the next check_stale! checkpoint, or when the syscall
+      # returns; either way it can no longer touch the live session.
       def interrupt_session(session_id)
-        thread = nil
         @registry.with_session(session_id) do |s|
           s[:idle_timer]&.cancel
           thread = s[:thread]
-
           next unless thread&.alive?
 
-          Clacky::Logger.info("[interrupt] session=#{session_id} tier=1 raise")
+          Clacky::Logger.info("[interrupt] session=#{session_id} raise")
           begin
             thread.raise(Clacky::AgentInterrupted, "Interrupted by user")
           rescue ThreadError => e
-            Clacky::Logger.warn("[interrupt] tier=1 raise failed: #{e.message}")
+            Clacky::Logger.warn("[interrupt] raise failed: #{e.message}")
           end
         end
-
-        return unless thread&.alive?
-
-        start_interrupt_watchdog(session_id, thread)
-      end
-
-      # Background watchdog: escalates from WebSocket force-close (tier 2)
-      # to Thread#kill (tier 3) if the agent thread refuses to die.
-      private def start_interrupt_watchdog(session_id, thread)
-        Thread.new do
-          Thread.current.name = "interrupt-watchdog[#{session_id}]" rescue nil
-
-          # Give the first Thread#raise a few seconds to unwind.
-          sleep 3
-          next unless thread.alive?
-
-          Clacky::Logger.warn(
-            "[interrupt] session=#{session_id} tier=2 raise failed after 3s, " \
-            "force-closing session resources"
-          )
-          force_close_session_sockets(session_id)
-          # Re-raise — sometimes the first raise was swallowed deep in a
-          # C-extension syscall; after we force-close the socket the
-          # syscall returns and the next raise sticks.
-          begin
-            thread.raise(Clacky::AgentInterrupted, "Interrupted by user (escalated)")
-          rescue ThreadError
-            # already dead between checks — fine
-          end
-
-          sleep 5
-          next unless thread.alive?
-
-          Clacky::Logger.error(
-            "[interrupt] session=#{session_id} tier=3 still alive after 8s, Thread#kill"
-          )
-          begin
-            thread.kill
-          rescue StandardError => e
-            Clacky::Logger.error("[interrupt] Thread#kill raised: #{e.class}: #{e.message}")
-          end
-
-          # Record the forced-kill so the UI can show a warning and operators
-          # can correlate with any backtrace dumps. The session is left in
-          # :idle state by run_agent_task's rescue clause; if the kill
-          # happened before the rescue could run, patch the state directly.
-          begin
-            @registry.update(session_id, status: :idle, error: "Force-killed (interrupt watchdog)")
-            broadcast_session_update(session_id)
-          rescue StandardError
-            # best effort
-          end
-        end
-      end
-
-      # Close every WebSocket connection bound to the given session. Used by
-      # the interrupt watchdog to unblock agent threads stuck in a WS write.
-      private def force_close_session_sockets(session_id)
-        conns = @ws_mutex.synchronize { (@ws_clients[session_id] || []).dup }
-        conns.each do |conn|
-          Clacky::Logger.warn(
-            "[interrupt] session=#{session_id} force-closing WS conn"
-          )
-          conn.force_close!
-        end
-      rescue StandardError => e
-        Clacky::Logger.error("[interrupt] force_close_session_sockets error: #{e.class}: #{e.message}")
-      end
-
-      # Run a task in a session immediately in the background, without waiting
+      end      # Run a task in a session immediately in the background, without waiting
       # for the client to subscribe. The user bubble is persisted via
       # display_text (Agent#run → history → replay_history), so the frontend
       # only needs to navigate over and load history — no realtime broadcast,
@@ -6008,11 +5989,19 @@ module Clacky
         # Cancel any pending idle compression before starting a new task
         idle_timer&.cancel
 
-        # Mark running BEFORE evict_excess_idle! — otherwise this session
+        # Claim a fresh epoch and mark running atomically-ish. The epoch
+        # fences this task against an interrupted-but-not-yet-dead predecessor:
+        # the old thread compares its epoch before writing status or
+        # broadcasting and silently drops anything once superseded. Without
+        # this a slow old thread could overwrite :running back to :idle (or
+        # close the new task's sockets), leaving the UI stuck "running".
+        #
+        # Marked running BEFORE evict_excess_idle! — otherwise this session
         # (still :idle here) can be evicted from the registry along with
         # other idle agents, breaking subsequent status updates and any
         # follow-up handle_user_message (which would early-return on
         # @registry.exist? == false).
+        epoch = @registry.claim_epoch(session_id)
         @registry.update(session_id, status: :running)
 
         # evict_excess_idle! serializes + writes 1 file per evicted session
@@ -6028,8 +6017,9 @@ module Clacky
         locale = Thread.current[:lang]
         thread = Thread.new do
           Thread.current[:lang] = locale
+          Thread.current[:task_epoch] = epoch
           task.call
-          @registry.update(session_id, status: :idle, error: nil)
+          next unless @registry.update_if_epoch(session_id, epoch, status: :idle, error: nil)
           broadcast_session_update(session_id)
           # Transient global signal for the optional task-complete sound. Sent to
           # all clients (broadcast_all) so a browser viewing another session — or
@@ -6040,7 +6030,9 @@ module Clacky
           # Start idle compression timer now that the agent is idle
           idle_timer&.start
         rescue Clacky::AgentInterrupted
-          @registry.update(session_id, status: :idle)
+          # A superseding task already owns the session — do not touch status
+          # or push UI events, they belong to the new epoch now.
+          next unless @registry.update_if_epoch(session_id, epoch, status: :idle)
           broadcast_session_update(session_id)
           broadcast(session_id, { type: "interrupted", session_id: session_id })
           @session_manager.save(agent.to_session_data(status: :interrupted))
@@ -6056,12 +6048,14 @@ module Clacky
           end
           user_message = e.respond_to?(:display_message) && e.display_message ? e.display_message : e.message
           raw_message  = e.respond_to?(:raw_message) ? e.raw_message : nil
-          @registry.update(session_id, status: :error, error: user_message, error_code: code, top_up_url: top_up_url, raw_message: raw_message)
+          next unless @registry.update_if_epoch(session_id, epoch, status: :error, error: user_message, error_code: code, top_up_url: top_up_url, raw_message: raw_message)
           broadcast_session_update(session_id)
           web_ui&.show_error(user_message, code: code, top_up_url: top_up_url, raw_message: raw_message)
           @session_manager.save(agent.to_session_data(status: :error, error_message: user_message, raw_message: raw_message))
         end
-        @registry.with_session(session_id) { |s| s[:thread] = thread }
+        # Register the thread only if we still own the epoch; a faster
+        # superseding task may have already replaced it.
+        @registry.with_session(session_id) { |s| s[:thread] = thread if s[:epoch].to_i == epoch.to_i }
       end
 
       # ── WebSocket subscription management ─────────────────────────────────────
@@ -6091,6 +6085,15 @@ module Clacky
       # removed automatically. Connections already marked closed are skipped
       # upfront so one sluggish client can't delay delivery to healthy ones.
       def broadcast(session_id, event)
+        # Drop events emitted by a superseded agent thread. A thread carrying a
+        # :task_epoch only gets through while it still owns the session; an
+        # interrupted-but-unwinding old thread (e.g. a late show_progress
+        # "done" from an ensure block) is silently dropped so it can't disturb
+        # the new task's UI. Threads without :task_epoch (HTTP handlers, the
+        # task supervisor itself) are never affected.
+        my_epoch = Thread.current[:task_epoch]
+        return if my_epoch && @registry.current_epoch(session_id) != my_epoch
+
         clients = @ws_mutex.synchronize { (@ws_clients[session_id] || []).dup }
         dead = []
         clients.each do |conn|

data/lib/clacky/server/session_registry.rb

@@ -49,6 +49,7 @@ module Clacky
           agent:                nil,
           ui:                   nil,
           thread:               nil,
+          epoch:                0,
           idle_timer:           nil,
           pending_task:         nil,
           pending_working_dir:  nil
@@ -138,6 +139,40 @@ module Clacky
         end
       end
 
+      # Atomically bump the session's task epoch and return the new value.
+      # Each user message that starts a task claims a fresh epoch; a stale task
+      # thread (interrupted but not yet dead) compares its epoch against the
+      # current one and discards any side effects (status writes, broadcasts)
+      # once it has been superseded.
+      def claim_epoch(session_id)
+        @mutex.synchronize do
+          session = @sessions[session_id]
+          return nil unless session
+
+          session[:epoch] = session[:epoch].to_i + 1
+        end
+      end
+
+      # Current task epoch for a session (0 if none / unknown).
+      def current_epoch(session_id)
+        @mutex.synchronize { @sessions[session_id]&.fetch(:epoch, 0).to_i }
+      end
+
+      # Update fields only if the caller still owns the current epoch. Returns
+      # true if the update was applied, false if the epoch was stale (a newer
+      # task has taken over) or the session is gone.
+      def update_if_epoch(session_id, epoch, **fields)
+        @mutex.synchronize do
+          session = @sessions[session_id]
+          return false unless session
+          return false unless session[:epoch].to_i == epoch.to_i
+
+          fields[:updated_at] = Time.now
+          session.merge!(fields)
+          true
+        end
+      end
+
       # Return a session list from disk enriched with live registry status.
       # Sorted by created_at descending (newest first).
       #
@@ -161,7 +196,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, include_pinned: true)
+      def list(limit: nil, before: nil, q: nil, q_scope: "name", date: nil, type: nil, exclude_type: nil, include_pinned: true)
         return [] unless @session_manager
 
         live = @mutex.synchronize do
@@ -196,6 +231,12 @@ module Clacky
           end
         end
 
+        # ── exclude_type filter ───────────────────────────────────────────────
+        if exclude_type
+          excluded = Array(exclude_type)
+          all = all.reject { |s| excluded.include?(s_source(s)) }
+        end
+
         # ── date filter (YYYY-MM-DD, matches created_at prefix) ──────────────
         all = all.select { |s| s[:created_at].to_s.start_with?(date) } if date
 
@@ -349,6 +390,14 @@ module Clacky
         @session_manager.all_sessions.count { |s| s_source(s) == "cron" }
       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 }
+      end
+
       # Delete a session from registry (and interrupt its thread).
       def delete(session_id)
         @mutex.synchronize do

data/lib/clacky/session_manager.rb

@@ -35,7 +35,7 @@ module Clacky
 
       # Keep only the most recent 200 sessions (best-effort, never block save)
       begin
-        cleanup_by_count(keep: 200)
+        cleanup_by_count(keep: 200, keep_cron: 200)
       rescue Exception # rubocop:disable Lint/RescueException
         # Cleanup is non-critical; swallow all errors (including AgentInterrupted)
       end
@@ -163,6 +163,33 @@ module Clacky
       chunk_path
     end
 
+    # Read the raw markdown of a chunk file. Returns nil if missing.
+    def read_chunk(chunk_path)
+      return nil unless chunk_path && File.exist?(chunk_path)
+      File.read(chunk_path)
+    end
+
+    # Split raw chunk markdown into [front_matter_hash, body_string].
+    # front_matter_hash preserves insertion order; body is everything after
+    # the closing "---". Returns [nil, raw] when there is no leading block.
+    def split_chunk_md(raw)
+      return [nil, raw.to_s] unless raw.to_s.start_with?("---")
+
+      fm_end = raw.index("\n---\n", 4)
+      return [nil, raw] unless fm_end
+
+      fm_text = raw[4...fm_end]
+      body    = raw[(fm_end + 5)..] || ""
+
+      fm = {}
+      fm_text.each_line do |line|
+        k, _, v = line.chomp.partition(":")
+        next if k.strip.empty?
+        fm[k.strip] = v.strip
+      end
+      [fm, body]
+    end
+
     # All sessions from disk, newest-first (sorted by last activity / updated_at,
     # falling back to created_at for legacy sessions without updated_at).
     # Optional filters:
@@ -305,11 +332,15 @@ module Clacky
     # 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:)
+    def cleanup_by_count(keep:, keep_cron: 200)
       non_pinned = all_sessions.reject { |s| s[:pinned] } # already sorted newest-first
-      return 0 if non_pinned.size <= keep
 
-      victims = non_pinned[keep..]
+      cron, regular = non_pinned.partition { |s| s[:source].to_s == "cron" }
+
+      victims = []
+      victims += regular[keep..] if regular.size > keep
+      victims += cron[keep_cron..] if cron.size > keep_cron
+
       victims.each { |session| soft_delete(session[:session_id]) }
       victims.size
     end

data/lib/clacky/ui2/layout_manager.rb

@@ -120,28 +120,23 @@ module Clacky
         @render_mutex.synchronize do
           entry = @buffer.entry_by_id(id)
           if entry.nil?
-            Clacky::Logger.warn("[ph_debug] replace_entry_nil", id: id, content: content.to_s[0, 120])
             return
           end
           if entry.committed
-            Clacky::Logger.warn("[ph_debug] replace_entry_committed", id: id, content: content.to_s[0, 120])
             return
           end
           if (entry.committed_line_offset || 0) > 0
-            Clacky::Logger.warn("[ph_debug] replace_entry_partial", id: id, offset: entry.committed_line_offset, content: content.to_s[0, 120])
             return
           end
 
           old_lines = entry.lines.dup
           new_lines = wrap_content_to_lines(content)
           if old_lines == new_lines
-            Clacky::Logger.warn("[ph_debug] replace_entry_same", id: id)
             screen.flush
             return
           end
           @buffer.replace(id, new_lines)
           is_tail = @buffer.live_entries.last&.id == id
-          Clacky::Logger.warn("[ph_debug] replace_entry_paint", id: id, is_tail: is_tail, old_n: old_lines.length, new_n: new_lines.length, content: content.to_s[0, 120])
 
           unless @fullscreen_mode
             # repaint_entry_in_place relies on the entry being the tail of

data/lib/clacky/ui2/progress_handle.rb

@@ -182,7 +182,6 @@ module Clacky
       # @param final_message [String, nil] Optional override for the last
       #   frame. If nil, the handle composes "<message>… (<elapsed>s)".
       def finish(final_message: nil)
-        Clacky::Logger.warn("[ph_debug] finish_entry", oid: object_id, state: @state, unreg: @unregistered, msg: @message, eid: @entry_id)
         snapshot = @monitor.synchronize do
           return if @unregistered
           first_close = @state == :running
@@ -201,10 +200,8 @@ module Clacky
           else
             compose_final_frame(snapshot[:message], snapshot[:elapsed])
           end
-        Clacky::Logger.warn("[ph_debug] finish_unregister", oid: object_id, eid: @entry_id, first_close: snapshot[:first_close], final_frame: final_frame.to_s[0, 200])
         @owner.unregister_progress(self, final_frame: final_frame)
         @monitor.synchronize { @unregistered = true }
-        Clacky::Logger.warn("[ph_debug] finish_done", oid: object_id)
       end
       alias_method :cancel, :finish
 

data/lib/clacky/ui2/ui_controller.rb

@@ -664,22 +664,13 @@ module Clacky
 
       # Called by ProgressHandle#finish.
       def unregister_progress(handle, final_frame:)
-        Clacky::Logger.warn("[ph_debug] unreg_entry", oid: handle.object_id, eid: handle.entry_id, top: @progress_stack.last == handle, stack_size: @progress_stack.size, ff: final_frame.to_s[0, 200])
         @progress_mutex.synchronize do
-          # If this handle still holds its entry (it's currently top), we
-          # render one last frame there and release the id. If it was
-          # previously detached (someone above is still active), its entry
-          # is already gone and the final_frame is simply dropped.
           if handle.entry_id
             if final_frame && !final_frame.to_s.strip.empty?
-              Clacky::Logger.warn("[ph_debug] unreg_update_entry", oid: handle.object_id, eid: handle.entry_id)
               update_entry(handle.entry_id, @renderer.render_progress(final_frame))
             else
-              Clacky::Logger.warn("[ph_debug] unreg_remove_entry", oid: handle.object_id, eid: handle.entry_id)
               remove_entry(handle.entry_id)
             end
-          else
-            Clacky::Logger.warn("[ph_debug] unreg_no_entry_id", oid: handle.object_id)
           end
 
           @progress_stack.delete(handle)

data/lib/clacky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clacky
-  VERSION = "1.3.5"
+  VERSION = "1.3.6"
 end

data/lib/clacky/web/app.css

@@ -4486,6 +4486,7 @@ body {
   border-radius: 10px;
   padding: 0.625rem 0.875rem;
   background: var(--color-bg-secondary);
+  margin-bottom: 0.625rem;
 }
 .backup-auto-card .backup-auto-row {
   margin: 0.25rem 0;
@@ -4517,6 +4518,43 @@ body {
   font-size: 0.75rem;
   color: var(--color-text-secondary);
 }
+.backup-dest-row {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  margin: 0.625rem 0 0.25rem;
+  padding-top: 0.625rem;
+  border-top: 1px solid var(--color-border-primary);
+}
+.backup-dest-label {
+  font-size: 0.78125rem;
+  color: var(--color-text-secondary);
+  white-space: nowrap;
+  flex-shrink: 0;
+}
+.backup-dest-path {
+  font-size: 0.78125rem;
+  color: var(--color-text-primary);
+  font-family: var(--font-mono, monospace);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.btn-settings-link {
+  flex-shrink: 0;
+  background: transparent;
+  border: 1px solid var(--color-border-primary);
+  border-radius: 6px;
+  color: var(--color-accent-primary);
+  font-size: 0.75rem;
+  padding: 0.25rem 0.625rem;
+  cursor: pointer;
+  white-space: nowrap;
+}
+.btn-settings-link:hover {
+  background: var(--color-bg-hover);
+  border-color: var(--color-accent-primary);
+}
 .backup-actions {
   display: flex;
   align-items: center;
@@ -4524,6 +4562,21 @@ body {
   flex-wrap: wrap;
 }
 
+.backup-config-row {
+  margin-top: 0.5rem;
+  padding-top: 0.75rem;
+  border-top: 1px solid var(--color-border);
+}
+.btn-settings-action--file {
+  cursor: pointer;
+}
+.backup-actions-sep {
+  width: 1px;
+  height: 1.25rem;
+  background: var(--color-border);
+  flex-shrink: 0;
+}
+
 .settings-network-url {
   display: flex;
   flex-direction: column;
@@ -7548,7 +7601,7 @@ body.setup-mode[data-theme="dark"] {
   cursor: pointer;
   transition: background .15s, opacity .15s;
 }
-.setup-submit-btn:hover    { background: #2563eb; }
+.setup-submit-btn:hover    { background: var(--color-button-primary-hover); }
 .setup-submit-btn:disabled { opacity: .5; cursor: default; }
 
 /* ── Onboard panel ───────────────────────────────────────────────────────── */