openclacky 1.2.17 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a0f79d1b7995b24b2b1a5d31dc36d4342ad1ff925b66749b7edb6268d0bcf29
-  data.tar.gz: b1f583cde8ffb619a4cb3558f074c369251c5445acce05116d1bc415e94eb3b4
+  metadata.gz: 8423d4e64f056251f1763e5cc34502e394f08e2b26de993da5da6a85a88111ef
+  data.tar.gz: 62e60aee3f8654e881870117b4716e053ab0f9328bc3898392ff1ed27517474c
 SHA512:
-  metadata.gz: 18921df7e5d4d4a7f3cbf1e19bd1b65bbc8360fa064d81ffc129375d86ec9a07ebfc324414d67a7d6df9782dfd8f966065755d0224d8af77b92604d6320195e2
-  data.tar.gz: 013db4dddea3c901bd3e8885241676b7fdd2ca2856a9a4df4cfde4b2475b7e57dc7795386d53db934acfe5786515501fd724e3ef559e8d5e786a6b07a3312db6
+  metadata.gz: d675c6b981a1fc5f24bbee79dd19dc273817a7f4e233c2ed86a42def4f2fd2876cbc845a9f693383d7f4b67d39f6a62df1eafa65def2a8ace7bb876559c6aba5
+  data.tar.gz: 48adb156c4c8ab26d2908537ac409c161a56b1f6fa5aa2146bdaa5df6b11c2b333e5a04a6aafc4404f1c94ce210fe0c23854d0f86f9cc509f1a27a781f9aa007

data/CHANGELOG.md

@@ -5,6 +5,40 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.3.0] - 2026-06-17
+
+### Added
+- Complete Web UI overhaul: skeleton loading, task card layout, new session dialog, onboarding flow, inline image preview, and redesigned session bar
+- Multimedia generation: video generation, text-to-speech (TTS), and OCR via vision models
+- IM channel management UI — bind and unbind channels directly in Web UI
+- `/model` command in terminal UI for quick model switching
+- AI-key device login flow
+- Session sharing and backup support
+
+### Improved
+- Terminal output auto-collapses on completion with normalized result display
+- Billing page mobile layout, global tooltip, and logo animation polish
+- Live chat history API replaces group buffer polling for real-time sync
+
+### Fixed
+- Sidebar scrolling back to active session on content updates
+- Channel key missing arbitration on session restore
+- Race condition in model switching
+- Channel keys and info out of sync on bind/unbind
+
+## [1.2.18] - 2026-06-13
+
+### Added
+- Alibaba DashScope (Qwen-Image) as a new image generation backend
+- "Always show" toggle for media-gen and skill-creators default skills, keeping them visible in all sessions
+
+### Fixed
+- Brand skill files not accessible outside their initial session context
+- `/model` command
+
+### More
+- Brand skills page now auto-refreshes on enter
+
 ## [1.2.17] - 2026-06-12
 
 ### Added

data/lib/clacky/agent/skill_manager.rb

@@ -346,7 +346,7 @@ module Clacky
 
         # For encrypted brand skills with supporting scripts: decrypt to a tmpdir so the
         # LLM receives the real paths it can execute. The tmpdir is registered on the agent
-        # and shredded when agent.run completes (see Agent#shred_script_tmpdirs).
+        # and lives for the agent's lifetime (the session).
         script_dir = nil
         if skill.encrypted? && skill.has_supporting_files?
           script_dir = Dir.mktmpdir("clacky-skill-#{skill.identifier}-")

data/lib/clacky/agent/time_machine.rb

@@ -1,10 +1,41 @@
 # frozen_string_literal: true
 
+require "fileutils"
+require "set"
+
 module Clacky
   class Agent
-    # Time Machine module for task history management with undo/redo support
-    # Stores complete file snapshots (AFTER state) to support message compression
+    # Time Machine module for task history management with undo/redo support.
+    #
+    # Snapshots capture the BEFORE state of each file the moment a task first
+    # touches it (via record_file_before_change). task-N/ therefore holds
+    # "what every file looked like just before task N changed it" — including
+    # an .absent marker for files that did not yet exist. Restoring to task T
+    # replays the earliest BEFORE recorded in any task after T, which equals
+    # the on-disk state at the end of task T.
     module TimeMachine
+      # Marker file written alongside a snapshot path when the original file
+      # did not exist before the task changed it. Restoring such an entry
+      # deletes the file instead of copying content back.
+      ABSENT_MARKER = ".clacky-absent"
+
+      # Root directory holding per-session file snapshots.
+      def self.snapshots_root
+        File.join(Dir.home, ".clacky", "snapshots")
+      end
+
+      # Snapshot directory for a single session.
+      def self.session_dir(session_id)
+        File.join(snapshots_root, session_id.to_s)
+      end
+
+      # Remove all snapshots for a session. Safe to call when none exist.
+      def self.delete_session_snapshots(session_id)
+        return if session_id.to_s.empty?
+
+        FileUtils.rm_rf(session_dir(session_id))
+      end
+
       # Initialize Time Machine state
       private def init_time_machine
         @task_parents ||= {}      # { task_id => parent_id }
@@ -15,6 +46,12 @@ module Clacky
       # Start a new task and establish parent relationship
       # Made public for testing
       def start_new_task
+        # Before the currently-active task stops being the latest, freeze its
+        # end-of-task disk state into an AFTER snapshot. Without this, a task
+        # that later gets superseded by a sibling branch would have no record
+        # of its result, making a forward switch back to it impossible.
+        checkpoint_latest_task_after
+
         parent_id = @active_task_id
         @current_task_id += 1
         @active_task_id = @current_task_id
@@ -26,101 +63,242 @@ module Clacky
         # before it can write to history.
         @task_thread = Thread.current
 
+        @latest_after_dirty = true
+
         @current_task_id
       end
 
-      # Save snapshots of modified files (AFTER state)
-      # @param modified_files [Array<String>] List of file paths that were modified
+      # Record a file's BEFORE state for the current task, the first time the
+      # task touches it. Call this immediately before a tool mutates the file.
+      # Subsequent calls within the same task are no-ops so the earliest state
+      # (the true "before this task" snapshot) is preserved.
       # Made public for testing
-      def save_modified_files_snapshot(modified_files)
-        return if modified_files.nil? || modified_files.empty?
-
-        snapshot_dir = File.join(
-          Dir.home,
-          ".clacky",
-          "snapshots",
-          @session_id,
-          "task-#{@current_task_id}"
-        )
-        FileUtils.mkdir_p(snapshot_dir)
-
-        modified_files.each do |file_path|
-          next unless File.exist?(file_path)
-
-          # Save file content to snapshot
-          relative_path = file_path.start_with?(@working_dir) ?
-            file_path.sub(@working_dir + "/", "") : File.basename(file_path)
-          
-          snapshot_file = File.join(snapshot_dir, relative_path)
-          FileUtils.mkdir_p(File.dirname(snapshot_file))
-          FileUtils.cp(file_path, snapshot_file)
+      def record_file_before_change(file_path)
+        return if @current_task_id.to_i <= 0
+
+        full_path = File.expand_path(file_path.to_s, @working_dir)
+        rel = snapshot_relative_path(full_path)
+        before_dir = File.join(TimeMachine.session_dir(@session_id), "task-#{@current_task_id}", "before")
+        snapshot_file = File.join(before_dir, rel)
+        marker_file   = "#{snapshot_file}.#{ABSENT_MARKER}"
+
+        # Already recorded for this task — keep the earliest capture.
+        return if File.exist?(snapshot_file) || File.exist?(marker_file)
+
+        # A fresh change to the latest task invalidates its stale AFTER checkpoint.
+        @latest_after_dirty = true
+
+        FileUtils.mkdir_p(File.dirname(snapshot_file))
+        if File.exist?(full_path)
+          FileUtils.cp(full_path, snapshot_file)
+        else
+          # File did not exist before this task — mark it so a restore deletes it.
+          FileUtils.touch(marker_file)
         end
-      rescue StandardError => e
-        # Silently handle errors in tests
+      rescue StandardError
+        # Snapshotting must never break the actual file operation.
       end
 
-      # Restore files to the state at given task
+      # Snapshot a task's current on-disk state into its AFTER tree, so a
+      # forward switch (redo / branch switch) back to it can be reconstructed.
+      # Only the files the task touched (its BEFORE entries) are captured.
+      # Defaults to the active task, which holds the live disk state right
+      # before we leave it (start_new_task / switch).
+      private def checkpoint_latest_task_after(task_id = @active_task_id)
+        return if task_id.to_i <= 0
+        # Re-snapshotting the latest task is skipped when nothing changed.
+        return if task_id == @current_task_id && @latest_after_dirty == false
+
+        session_root = TimeMachine.session_dir(@session_id)
+        before_dir = File.join(session_root, "task-#{task_id}", "before")
+        return unless Dir.exist?(before_dir)
+
+        after_dir = File.join(session_root, "task-#{task_id}", "after")
+        FileUtils.rm_rf(after_dir)
+
+        Dir.glob(File.join(before_dir, "**", "*"), File::FNM_DOTMATCH).each do |path|
+          next if File.directory?(path)
+
+          rel = path.sub(before_dir + "/", "")
+          rel = rel.sub(/\.#{Regexp.escape(ABSENT_MARKER)}\z/, "")
+          target = File.join(@working_dir, rel)
+          dest = File.join(after_dir, rel)
+          if File.exist?(target)
+            FileUtils.mkdir_p(File.dirname(dest))
+            FileUtils.cp(target, dest)
+          else
+            FileUtils.mkdir_p(File.dirname(dest))
+            FileUtils.touch("#{dest}.#{ABSENT_MARKER}")
+          end
+        end
+        @latest_after_dirty = false if task_id == @current_task_id
+      rescue StandardError
+        # Checkpointing must never break a restore.
+      end
+
+      # Restore files to the on-disk state at the END of the given task.
+      #
+      # History is a TREE (undo + a new message forks a sibling branch), so a
+      # linear "replay every task after T" model is wrong: a sibling branch's
+      # files would leak in or get wrongly deleted. Instead we reconstruct T's
+      # end state from the task tree:
+      #
+      #   * Each task owns an AFTER snapshot = the content of the files it
+      #     touched, as they looked when that task finished.
+      #   * To rebuild "end of task T", walk T's ancestor chain (T -> root).
+      #     For every file ever touched in the whole session, the winning
+      #     content is the closest ancestor (starting at T) whose AFTER holds
+      #     that file. If no ancestor on the chain ever touched it, the file
+      #     did not exist at T and is removed.
+      #
       # @param task_id [Integer] Target task ID
       # Made public for testing
       def restore_to_task_state(task_id)
-        # Collect all modified files from task 1 to target task
-        files_to_restore = {}
-        
-        (1..task_id).each do |tid|
-          snapshot_dir = File.join(
-            Dir.home,
-            ".clacky",
-            "snapshots",
-            @session_id,
-            "task-#{tid}"
-          )
-          
-          next unless Dir.exist?(snapshot_dir)
-          
-          Dir.glob(File.join(snapshot_dir, "**", "*")).each do |snapshot_file|
-            next if File.directory?(snapshot_file)
-            
-            relative_path = snapshot_file.sub(snapshot_dir + "/", "")
-            files_to_restore[relative_path] = snapshot_file
-          end
+        # Freeze the task we're leaving so a later forward switch can return.
+        checkpoint_latest_task_after
+
+        session_root = TimeMachine.session_dir(@session_id)
+
+        # Ancestor chain from the target task up to (and excluding) root 0,
+        # ordered nearest-first so the closest writer of each file wins.
+        ancestors = []
+        tid = task_id
+        until tid.nil? || tid <= 0 || ancestors.include?(tid)
+          ancestors << tid
+          tid = @task_parents[tid]
         end
-        
-        # Restore files
-        files_to_restore.each do |relative_path, snapshot_file|
-          target_file = File.join(@working_dir, relative_path)
-          FileUtils.mkdir_p(File.dirname(target_file))
-          FileUtils.cp(snapshot_file, target_file)
+
+        # Every file ever touched by any task in this session.
+        all_rels = Set.new
+        Dir.glob(File.join(session_root, "task-*", "before", "**", "*"), File::FNM_DOTMATCH).each do |path|
+          next if File.directory?(path)
+
+          rel = path.sub(%r{\A.*/before/}, "")
+          rel = rel.sub(/\.#{Regexp.escape(ABSENT_MARKER)}\z/, "")
+          all_rels << rel
+        end
+
+        all_rels.each do |rel|
+          action = :delete
+          source = nil
+          matched = false
+
+          # Closest ancestor (starting at the target) that produced this file.
+          ancestors.each do |aid|
+            after_dir = File.join(session_root, "task-#{aid}", "after")
+            content_path = File.join(after_dir, rel)
+            absent_path  = "#{content_path}.#{ABSENT_MARKER}"
+
+            if File.exist?(content_path)
+              action = :restore
+              source = content_path
+              matched = true
+              break
+            elsif File.exist?(absent_path)
+              action = :delete
+              matched = true
+              break
+            end
+          end
+
+          # No task on the chain produced this file. Restore the session's
+          # INITIAL content for it — captured as the earliest BEFORE recorded
+          # for this file by any task (BEFORE = state just before that task
+          # ran; the smallest task id therefore holds the pre-session state).
+          # No BEFORE at all => the file never existed initially, so delete.
+          unless matched
+            initial = earliest_before_snapshot(session_root, rel)
+            if initial
+              action = :restore
+              source = initial
+            else
+              action = :delete
+            end
+          end
+
+          target = File.join(@working_dir, rel)
+          if action == :delete
+            FileUtils.rm_f(target)
+          else
+            FileUtils.mkdir_p(File.dirname(target))
+            FileUtils.cp(source, target)
+          end
         end
-      rescue StandardError => e
-        # Silently handle errors in tests
+      rescue StandardError
         raise
       end
 
-      # Filter messages to only show tasks up to active_task_id.
-      # This hides "future" messages when user has undone.
-      # Returns API-ready array (strips internal fields + handles orphaned tool_calls).
+      # The initial (pre-session) content path for a file, taken from the
+      # earliest BEFORE snapshot any task recorded for it. Returns the snapshot
+      # path to copy back, or nil if the earliest record is an absent marker
+      # (file did not exist at the session start).
+      private def earliest_before_snapshot(session_root, rel)
+        task_ids = Dir.glob(File.join(session_root, "task-*")).filter_map do |dir|
+          m = File.basename(dir).match(/\Atask-(\d+)\z/)
+          m && m[1].to_i
+        end.sort
+
+        task_ids.each do |tid|
+          before_dir = File.join(session_root, "task-#{tid}", "before")
+          content_path = File.join(before_dir, rel)
+          absent_path  = "#{content_path}.#{ABSENT_MARKER}"
+          return content_path if File.exist?(content_path)
+          return nil if File.exist?(absent_path)
+        end
+        nil
+      end
+
+      # Relative path used to key a snapshot. Files inside the working dir keep
+      # their relative path; anything else falls back to its basename.
+      private def snapshot_relative_path(full_path)
+        if full_path.start_with?(@working_dir + "/")
+          full_path.sub(@working_dir + "/", "")
+        else
+          File.basename(full_path)
+        end
+      end
+
+      # Filter messages to only the active task's ancestor chain.
+      # After an undo (and especially after sending a NEW message post-undo,
+      # which forks a fresh task off the undone point) the history still holds
+      # the abandoned/sibling-branch turns. We must send the LLM only the turns
+      # on the path from the root to the active task — never undone siblings.
+      # Returns API-ready array (strips internal fields + repairs orphaned
+      # tool_calls), so this stays consistent with the normal to_api path.
       # @param force_reasoning_content_pad [Boolean] forwarded to MessageHistory,
       #   enables one-shot pad-and-retry for thinking-mode providers that
       #   require reasoning_content on every assistant message.
       # Made public for testing
       def active_messages(force_reasoning_content_pad: false)
-        if @active_task_id == @current_task_id
-          return @history.to_api(force_reasoning_content_pad: force_reasoning_content_pad)
-        end
+        @history.to_api(
+          force_reasoning_content_pad: force_reasoning_content_pad,
+          task_chain: active_task_chain
+        )
+      end
 
-        stripped = @history.for_task(@active_task_id).map do |msg|
-          msg.reject { |k, _| MessageHistory::INTERNAL_FIELDS.include?(k) }
+      # The set of task IDs on the path from the root to @active_task_id,
+      # walked via @task_parents. Used to filter history so undone or
+      # sibling-branch turns are excluded from what the LLM sees. Task 0 is the
+      # root and is always included when reached (early turns are tagged 0).
+      private def active_task_chain
+        chain = Set.new
+        tid = @active_task_id
+        # Guard against a malformed parent map producing a cycle.
+        until tid.nil? || chain.include?(tid)
+          chain << tid
+          break if tid <= 0
+          tid = @task_parents[tid]
         end
-        # Apply the same reasoning_content padding rule used by to_api so
-        # Time Machine replays satisfy thinking-mode providers after a
-        # 400 retry.
-        MessageHistory.pad_reasoning_content_if_needed(stripped, force: force_reasoning_content_pad)
+        chain
       end
 
-      # Undo to parent task
+      # Undo to parent task. Task 0 represents the original pre-task state,
+      # which is reachable from task 1 thanks to its BEFORE snapshots.
       def undo_last_task
+        return { success: false, message: "Already at root task" } if @active_task_id == 0
+
         parent_id = @task_parents[@active_task_id]
-        return { success: false, message: "Already at root task" } if parent_id.nil? || parent_id == 0
+        return { success: false, message: "Already at root task" } if parent_id.nil?
 
         restore_to_task_state(parent_id)
         @active_task_id = parent_id
@@ -159,6 +337,8 @@ module Clacky
       def get_task_history(limit: 10)
         return [] if @current_task_id == 0
 
+        chain = active_task_chain
+
         tasks = []
         (1..@current_task_id).to_a.reverse.take(limit).reverse.each do |task_id|
           # Find first user message for this task
@@ -174,13 +354,15 @@ module Clacky
             "Task #{task_id}"
           end
 
-          # Determine task status
+          # Status relative to the ACTIVE task chain (not a linear id compare),
+          # so undone/abandoned branches are flagged distinctly from the path
+          # the user is currently on.
           status = if task_id == @active_task_id
             :current
-          elsif task_id < @active_task_id
+          elsif chain.include?(task_id)
             :past
           else
-            :future
+            :undone
           end
 
           # Check if task has branches (multiple children)

data/lib/clacky/agent/tool_executor.rb

@@ -254,6 +254,18 @@ module Clacky
         }
       end
 
+      # Show countdown before auto-executing in auto_approve mode.
+      # Gives the user time to see what's happening and Ctrl+C to cancel.
+      # @param seconds [Integer] Countdown duration
+      private def auto_approve_countdown(seconds: 10)
+        return unless @ui
+
+        seconds.downto(1) do |remaining|
+          @ui.show_info("  Auto-executing in #{remaining}s... (Ctrl+C to cancel)", prefix_newline: false)
+          sleep 1
+        end
+      end
+
       # Check if a tool is potentially slow and should show progress
       # @param tool_name [String] Name of the tool
       # @param args [Hash] Tool arguments

data/lib/clacky/agent.rb

@@ -42,7 +42,7 @@ module Clacky
 
     attr_reader :session_id, :name, :history, :iterations, :total_cost, :working_dir, :created_at, :total_tasks, :todos,
                 :cache_stats, :cost_source, :ui, :skill_loader, :agent_profile,
-                :status, :error, :updated_at, :source,
+                :status, :error, :updated_at, :source, :config,
                 :latest_latency,  # Hash of latency metrics from the most recent LLM call (see Client#send_messages_with_tools)
                 :reasoning_effort
     attr_accessor :pinned
@@ -102,7 +102,7 @@ module Clacky
       @ui = ui  # UIController for direct UI interaction
       @debug_logs = []  # Debug logs for troubleshooting
       @pending_injections = []     # Pending inline skill injections to flush after observe()
-      @pending_script_tmpdirs = [] # Decrypted-script tmpdirs to shred when agent.run completes
+      @pending_script_tmpdirs = [] # Decrypted-script tmpdirs that live for the agent's lifetime
       @pending_error_rollback = false  # Deferred rollback flag set by restore_session on error
       @last_run_interrupted = false    # Set when run() exits via AgentInterrupted; tells the next run() to keep the task-start snapshot (continuation of the same task across a relay, not a brand-new task)
 
@@ -605,12 +605,6 @@ module Clacky
 
       result = build_result
 
-      # Save snapshots of modified files for Time Machine
-      if @modified_files_in_task && !@modified_files_in_task.empty?
-        save_modified_files_snapshot(@modified_files_in_task)
-        @modified_files_in_task = []  # Reset for next task
-      end
-
         # Run skill evolution hooks after main loop completes
         # Skip if task was interrupted by user (denied tool) or awaiting user feedback
         # Only for main agent (not subagents) to avoid recursive evolution
@@ -677,11 +671,6 @@ module Clacky
         Clacky::Logger.warn("[ph_debug] agent_run_ensure")
         @ui&.show_progress(phase: "done")
 
-        # Shred any decrypted-script tmpdirs created during this run for encrypted brand skills.
-        # This covers the inline-injection path; the subagent path shreds immediately after
-        # subagent.run returns (see execute_skill_with_subagent).
-        shred_script_tmpdirs
-
         # Fire-and-forget telemetry after every agent run.
         # Tracks daily active users (distinct devices per day) and task volume.
         Clacky::Telemetry.task!(result: result)
@@ -958,8 +947,11 @@ module Clacky
           end
         end
 
-        # Special handling for request_user_feedback: don't show as tool call
-        unless call[:name] == "request_user_feedback"
+        # Special handling for request_user_feedback
+        if call[:name] == "request_user_feedback"
+          # In auto_approve mode, give user time to see and cancel before auto-answering
+          auto_approve_countdown(seconds: 10) if @config.permission_mode == :auto_approve
+        else
           @ui&.show_tool_call(call[:name], redact_tool_args(call[:arguments]))
         end
 
@@ -1009,6 +1001,10 @@ module Clacky
           # instant tools like edit/write/read/glob/grep. Truly slow
           # tools (terminal running a build, web_fetch) exceed the
           # threshold and their final frame is preserved as usual.
+          # Record BEFORE-change snapshots for Time Machine right before the
+          # tool runs, so undo can restore (or delete) any file it touches.
+          record_tool_target_before(call[:name], args)
+
           result = nil
           if @ui
             progress_message = build_tool_progress_message(call[:name], args)
@@ -1023,9 +1019,6 @@ module Clacky
             result = tool.execute(**args)
           end
 
-          # Track modified files for Time Machine snapshots
-          track_modified_files(call[:name], args)
-
           # Hook: after_tool_use
           @hooks.trigger(:after_tool_use, call, result)
 
@@ -1055,7 +1048,7 @@ module Clacky
           else
             # Use tool's format_result method to get display-friendly string
             formatted_result = tool.respond_to?(:format_result) ? tool.format_result(result) : result.to_s
-            @ui&.show_tool_result(formatted_result)
+            @ui&.show_tool_result(redact_tool_args(formatted_result))
           end
 
           results << build_success_result(call, result)
@@ -1073,7 +1066,7 @@ module Clacky
           Clacky::Logger.error("tool_execution_error", tool: call[:name], error: e)
 
           @hooks.trigger(:on_tool_error, call, e)
-          @ui&.show_tool_error(e)
+          @ui&.show_tool_error(redact_tool_args(e.message))
           # Use build_denied_result with system_injected=true so LLM knows it can retry
           results << build_denied_result(call, e.message, true)
         end
@@ -1176,8 +1169,8 @@ module Clacky
     end
 
     # Register a tmpdir that contains decrypted brand skill scripts.
-    # SkillManager calls this after decrypt_all_scripts so agent.run's ensure block
-    # can shred it when the run completes.
+    # SkillManager calls this after decrypt_all_scripts. The tmpdir lives for
+    # the agent's lifetime (a session), not just a single agent.run.
     # @param dir [String] Absolute path to the tmpdir
     def register_script_tmpdir(dir)
       @pending_script_tmpdirs << dir
@@ -1585,7 +1578,7 @@ module Clacky
 
       image = data_url ? { data_url: data_url } : { path: path }
 
-      @ui&.show_progress("OCR...", progress_type: "thinking", phase: "active")
+      @ui&.show_progress("Reading image…", progress_type: "vision", phase: "active")
       begin
         Clacky::Vision::Resolver.new(ocr_entry).describe(image)
       ensure
@@ -1814,17 +1807,14 @@ module Clacky
       @ui&.show_assistant_message(full_content, files: parsed[:files])
     end
 
-    # Track modified files for Time Machine snapshots
-    # @param tool_name [String] Name of the tool that was executed
+    # Record BEFORE-change snapshots for any file a tool is about to mutate,
+    # so Time Machine can later restore or delete it.
+    # @param tool_name [String] Name of the tool about to be executed
     # @param args [Hash] Arguments passed to the tool
-    def track_modified_files(tool_name, args)
-      @modified_files_in_task ||= []
-
+    private def record_tool_target_before(tool_name, args)
       case tool_name
       when "write", "edit"
-        file_path = args[:path]
-        full_path = File.expand_path(file_path, @working_dir)
-        @modified_files_in_task << full_path unless @modified_files_in_task.include?(full_path)
+        record_file_before_change(args[:path]) if args[:path]
       end
     end
   end

data/lib/clacky/agent_config.rb

@@ -825,6 +825,24 @@ module Clacky
       available = default_provider ? Clacky::Providers.ocr_models(default_provider) : []
 
       if raw_entry && raw_entry["disabled"]
+        # A disabled OCR sidecar only means "no separate vision model"; it must
+        # not override the fact that the chat model may handle images itself.
+        anchor = current_model || default
+        anchor_provider = anchor && Clacky::Providers.resolve_provider(
+          base_url: anchor["base_url"], api_key: anchor["api_key"]
+        )
+        if anchor && anchor_provider &&
+           Clacky::Providers.supports?(anchor_provider, :vision, model_name: anchor["model"])
+          return {
+            "configured" => true,
+            "source"     => "primary",
+            "model"      => anchor["model"],
+            "base_url"   => anchor["base_url"],
+            "provider"   => anchor_provider,
+            "primary"    => true,
+            "available"  => available
+          }
+        end
         return {
           "configured" => false,
           "source"     => "off",