openclacky 1.2.18 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fcf1cc94591160df5daf797ece584049cf5c9881bc1e3899e84d8fdee61d330f
-  data.tar.gz: cde0fb1ea11582f9e4934a68635b44af3bda3cf886619280d9c0afce6a36eb5e
+  metadata.gz: 8423d4e64f056251f1763e5cc34502e394f08e2b26de993da5da6a85a88111ef
+  data.tar.gz: 62e60aee3f8654e881870117b4716e053ab0f9328bc3898392ff1ed27517474c
 SHA512:
-  metadata.gz: 2395d1e2b130021001ebad6aafa7eb11d5a884201852030e203e237b8e91b6ef9c67b7d50b691661ccae66b6baccd941e8e9c6bf92ef2addd490166c57b06ab2
-  data.tar.gz: 32cad874d49b8df4892081a5e5ade95115fdb58c9c52fd88cd95d130aba0ae65068adf0966ab259cdf383bb8293fb6d4f43c5f0a9177844ac295355c1dcac94e
+  metadata.gz: d675c6b981a1fc5f24bbee79dd19dc273817a7f4e233c2ed86a42def4f2fd2876cbc845a9f693383d7f4b67d39f6a62df1eafa65def2a8ace7bb876559c6aba5
+  data.tar.gz: 48adb156c4c8ab26d2908537ac409c161a56b1f6fa5aa2146bdaa5df6b11c2b333e5a04a6aafc4404f1c94ce210fe0c23854d0f86f9cc509f1a27a781f9aa007

data/CHANGELOG.md

@@ -5,6 +5,27 @@ 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

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

@@ -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
@@ -953,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
 
@@ -1004,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)
@@ -1018,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)
 
@@ -1580,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
@@ -1809,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",

data/lib/clacky/cli.rb

@@ -290,6 +290,54 @@ module Clacky
         ui_controller.append_output("")
       end
 
+      # Handle the `/model` slash command — a quick model-card switcher.
+      #
+      # This is the lightweight counterpart to /config: it only lets the user
+      # pick an already-configured model and switches to it (no add/edit/delete).
+      # Switching goes through the unified Agent#switch_model_by_id path and
+      # also updates the global default so the choice sticks across launches,
+      # matching /config's :switch behavior.
+      private def handle_model_command(ui_controller, agent_config, agent, session_manager = nil)
+        config = agent_config
+
+        if config.models.empty?
+          ui_controller.show_error("No models configured. Run /config to add one.")
+          return
+        end
+
+        # Resolve a card's provider sub-models so the picker can offer them in
+        # the card's sub-model drawer.
+        submodels_for = lambda do |model|
+          base_url = model["base_url"]
+          provider_id = base_url && Clacky::Providers.find_by_base_url(base_url)
+          provider_id ? Clacky::Providers.models(provider_id) : []
+        end
+
+        result = ui_controller.show_model_switch_modal(config, submodels_for)
+        return if result.nil?
+
+        target_id = result[:model_id]
+        sub_model = result[:model_name]
+
+        agent.switch_model_by_id(target_id)
+        config.set_default_model_by_id(target_id)
+        config.save
+
+        # Pin (or clear) the per-session sub-model overlay for the chosen card.
+        agent.set_session_sub_model(sub_model)
+
+        # The overlay lives in the session file (not config.yml), so persist it
+        # now — otherwise it would be lost if the user quits before the next task.
+        session_manager&.save(agent.to_session_data)
+
+        ui_controller.config[:model] = config.model_name
+        ui_controller.update_sessionbar(
+          tasks: agent.total_tasks,
+          cost: agent.total_cost
+        )
+        ui_controller.show_success("Switched to model: #{config.model_name}")
+      end
+
       private def handle_time_machine_command(ui_controller, agent, session_manager)
         # Get task history from agent
         history = agent.get_task_history(limit: 10)
@@ -892,10 +940,11 @@ module Clacky
               ui_controller.append_output("")
             end
 
-            # Stop UI and exit
+            # Stop UI and exit. Each UI decides whether to clear the screen on
+            # exit (UI2 keeps it so the resume hint survives; Rich clears).
             shutting_down = true
             idle_timer.shutdown
-            ui_controller.stop(clear_screen: true)
+            ui_controller.stop
             exit(0)
           end
 
@@ -913,6 +962,9 @@ module Clacky
           when "/config"
             handle_config_command(ui_controller, agent_config, agent)
             next
+          when "/model"
+            handle_model_command(ui_controller, agent_config, agent, session_manager)
+            next
           when "/undo"
             handle_time_machine_command(ui_controller, agent, session_manager)
             next
@@ -948,7 +1000,7 @@ module Clacky
           when "/exit", "/quit"
             shutting_down = true
             idle_timer.shutdown
-            ui_controller.stop(clear_screen: true)
+            ui_controller.stop
             exit(0)
           when "/help"
             sleep 0.1