kward 0.69.1 → 0.71.0

data/lib/kward/cli/sessions.rb

@@ -1,3 +1,5 @@
+require "time"
+
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
@@ -106,6 +108,13 @@ module Kward
         path = select_session_path(session_store) if path.empty?
         return nil if path.to_s.empty?
 
+        load_session(session_store, path, message: "Resumed session")
+      rescue StandardError => e
+        runtime_output("Error: #{e.message}")
+        nil
+      end
+
+      def load_session(session_store, path, message: nil)
         previous_session = @active_session
         @active_session, conversation = session_store.load(path, workspace: configured_workspace(root: session_store.cwd), provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort)
         reset_session_diff(@active_session.path)
@@ -113,15 +122,12 @@ module Kward
         cleanup_replaced_session(previous_session)
         update_assistant_prompt(conversation)
         restore_prompt_transcript do
-          runtime_output("Resumed session: #{@active_session.path}")
+          runtime_output("#{message}: #{@active_session.path}") if message
           render_conversation_transcript(conversation)
         end
         agent = build_interactive_agent(conversation)
         @prompt.redraw if @prompt.respond_to?(:redraw) && !@prompt.respond_to?(:restore_transcript)
         agent
-      rescue StandardError => e
-        runtime_output("Error: #{e.message}")
-        nil
       end
 
       def navigate_session_tree(session_store)
@@ -131,7 +137,7 @@ module Kward
           return nil
         end
 
-        tree_items = session_tree_items(session_store)
+        tree_items = run_busy_local_command_and_requeue { session_tree_items(session_store) }
         if tree_items.empty?
           runtime_output("No session tree entries found.")
           return nil
@@ -147,8 +153,12 @@ module Kward
         entry = tree_items.find { |item| item[:entry]["id"].to_s == entry_id }&.fetch(:entry)
         return nil unless entry
 
-        selected_text = apply_session_tree_entry(entry)
-        runtime_output("Moved session tree position to #{entry["id"]}.")
+        selected_text = nil
+        agent = run_busy_local_command_and_requeue do
+          selected_text = apply_session_tree_entry(entry)
+          runtime_output("Moved session tree position to #{entry["id"]}.")
+          reload_active_session(session_store)
+        end
         if selected_text && !selected_text.empty?
           if @prompt.respond_to?(:prefill_input)
             @prompt.prefill_input(selected_text)
@@ -156,8 +166,7 @@ module Kward
             runtime_output("Selected text for editing:\n#{selected_text}")
           end
         end
-        agent = reload_active_session(session_store)
-        @prompt.redraw if @prompt.respond_to?(:redraw)
+        @prompt.redraw if @prompt.respond_to?(:redraw) && !@prompt.respond_to?(:restore_transcript)
         agent
       rescue StandardError => e
         runtime_output("Session tree error: #{e.message}")
@@ -175,11 +184,193 @@ module Kward
         answer.match?(/\A\d+\z/) ? labels[answer.to_i - 1] : nil
       end
 
+      def rewind_session(session_store)
+        return say_sessions_unavailable unless session_store
+        unless @active_session
+          runtime_output("No active persisted session.")
+          return nil
+        end
+
+        points = rewind_points(session_store)
+        if points.empty?
+          runtime_output("No prompts to rewind to.")
+          return nil
+        end
+
+        labels = points.map { |point| point[:label] }
+        choice = select_rewind_point(labels)
+        return nil unless choice
+
+        point = points[labels.index(choice)]
+        return nil unless point
+
+        if point[:return_leaf_id]
+          @active_session.branch(point[:return_leaf_id])
+          @rewind_return_leaf_id = nil
+        else
+          @rewind_return_leaf_id = @active_session.leaf_id || session_store.current_leaf(@active_session.path)
+          selected_text = apply_session_tree_entry(point[:entry])
+          if selected_text && !selected_text.empty?
+            if @prompt.respond_to?(:prefill_input)
+              @prompt.prefill_input(selected_text)
+            else
+              runtime_output("Selected prompt for editing:\n#{selected_text}")
+            end
+          end
+        end
+        agent = reload_active_session(session_store)
+        @prompt.redraw if @prompt.respond_to?(:redraw)
+        agent
+      rescue StandardError => e
+        runtime_output("Rewind error: #{e.message}")
+        nil
+      end
+
+      def select_rewind_point(labels)
+        if @prompt.respond_to?(:select)
+          return @prompt.select("Rewind>", labels, title: "Rewind")
+        end
+
+        numbered_labels = labels.each_with_index.map { |label, index| "#{index + 1}. #{label}" }
+        runtime_output((["Rewind to:"] + numbered_labels).join("\n"))
+        answer = @prompt.ask("Rewind point number>").to_s.strip
+        answer.match?(/\A\d+\z/) ? labels[answer.to_i - 1] : nil
+      end
+
+      def rewind_points(session_store)
+        entries = session_store.session_entries(@active_session.path)
+        current_leaf_id = @active_session.leaf_id || session_store.current_leaf(@active_session.path)
+        active_path = active_session_tree_entry_ids(entries, current_leaf_id)
+        user_entries = entries.select { |entry| rewind_entry?(entry) }
+        points = user_entries.reverse_each.with_index.map do |entry, index|
+          {
+            entry: entry,
+            label: rewind_point_label(entry, index, active_path.include?(entry["id"].to_s)),
+            timestamp: entry["timestamp"]
+          }
+        end
+        return_point = rewind_return_point(entries, current_leaf_id)
+        points = [return_point] + points if return_point
+        align_rewind_point_timestamps(points, picker_choice_width)
+      end
+
+      def rewind_return_point(entries, current_leaf_id)
+        return nil if @rewind_return_leaf_id.to_s.empty?
+        return nil if @rewind_return_leaf_id.to_s == current_leaf_id.to_s
+
+        entry = entries.find { |candidate| candidate["id"].to_s == @rewind_return_leaf_id.to_s }
+        return nil unless entry
+
+        {
+          return_leaf_id: @rewind_return_leaf_id,
+          label: "Return to where I was: #{truncate_rewind_text(rewind_return_text(entry))}",
+          timestamp: entry["timestamp"]
+        }
+      end
+
+      def align_rewind_point_timestamps(points, width)
+        labels = points.map { |point| point[:label].to_s }
+        label_width = labels.map(&:length).max.to_i
+        points.each do |point|
+          timestamp = relative_rewind_time(point[:timestamp])
+          next if timestamp.empty?
+
+          point[:label] = right_aligned_picker_metadata(point[:label], timestamp, width: width, minimum_label_width: label_width)
+        end
+      end
+
+      def right_aligned_picker_metadata(label, metadata, width:, minimum_label_width: 0)
+        label = label.to_s
+        metadata = metadata.to_s
+        fallback_width = minimum_label_width + metadata.length + 2
+        target_width = width.to_i.positive? ? width.to_i : fallback_width
+        label_width = [target_width - metadata.length - 2, 1].max
+        "#{truncate_picker_label(label, label_width).ljust(label_width)}  #{metadata}"
+      end
+
+      def truncate_picker_label(label, width)
+        return "" if width <= 0
+
+        text = label.to_s
+        return text if text.length <= width
+        return text.slice(0, width) if width <= 3
+
+        "#{text.slice(0, width - 3)}..."
+      end
+
+      def relative_rewind_time(timestamp)
+        time = timestamp.is_a?(Time) ? timestamp.utc : Time.iso8601(timestamp.to_s).utc
+        seconds = [(Time.now.utc - time).to_i, 0].max
+        case seconds
+        when 0...60
+          "just now"
+        when 60...3600
+          minutes = seconds / 60
+          "#{minutes} min ago"
+        when 3600...86_400
+          hours = seconds / 3600
+          "#{hours} h ago"
+        else
+          days = seconds / 86_400
+          "#{days} d ago"
+        end
+      rescue ArgumentError
+        ""
+      end
+
+      def rewind_return_text(entry)
+        message = entry["message"]
+        text = full_message_text(message) if message.is_a?(Hash)
+        text.to_s.empty? ? entry["id"].to_s : text
+      end
+
+      def rewind_entry?(entry)
+        return false unless entry["type"] == "message"
+
+        message = entry["message"]
+        message.is_a?(Hash) && message_role(message) == "user" && !full_message_text(message).empty?
+      end
+
+      def rewind_point_label(entry, index, active)
+        marker = active ? "• " : ""
+        prefix = case index
+                 when 0 then "Last prompt"
+                 when 1 then "2 turns ago"
+                 else "#{index + 1} turns ago"
+                 end
+        "#{marker}#{prefix}: #{truncate_rewind_text(full_message_text(entry["message"] || {}))}"
+      end
+
+      def active_session_tree_entry_ids(entries, leaf_id)
+        by_id = entries.to_h { |entry| [entry["id"].to_s, entry] }
+        ids = []
+        seen = {}
+        current = by_id[leaf_id.to_s]
+        while current && !seen[current["id"].to_s]
+          seen[current["id"].to_s] = true
+          ids << current["id"].to_s
+          current = by_id[current["parentId"].to_s]
+        end
+        ids
+      end
+
+      def truncate_rewind_text(text)
+        text.to_s.gsub(/\s+/, " ").strip
+      end
+
+      def picker_choice_width
+        if @prompt.respond_to?(:picker_choice_width)
+          @prompt.picker_choice_width
+        else
+          96
+        end
+      end
+
       def apply_session_tree_entry(entry)
         message = entry["message"]
         if message.is_a?(Hash) && message_role(message) == "user"
           target_leaf = entry["parentId"]
-          target_leaf.to_s.empty? ? @active_session.reset_leaf : @active_session.branch(target_leaf)
+          @active_session.branch(target_leaf) unless target_leaf.to_s.empty?
           return full_message_text(message)
         end
 
@@ -210,13 +401,19 @@ module Kward
         SessionTreeRenderer.new(roots: roots, current_leaf_id: current_leaf_id).items
       end
 
-      def rename_session(argument)
+      def rename_session(argument, require_name: false)
         unless @active_session
           runtime_output("No active persisted session.")
           return
         end
 
-        @active_session.rename(argument)
+        name = argument.to_s.strip
+        if require_name && name.empty?
+          runtime_output("Usage: /rename <name>")
+          return
+        end
+
+        @active_session.rename(name)
         label = @active_session.name ? "Named session: #{@active_session.name}" : "Cleared session name."
         runtime_output(label)
       end
@@ -233,6 +430,198 @@ module Kward
         agent
       end
 
+      def fork_session(session_store)
+        return say_sessions_unavailable unless session_store
+        unless @active_session
+          runtime_output("No active persisted session.")
+          return nil
+        end
+
+        points = fork_points(session_store)
+        if points.empty?
+          runtime_output("No prompts to fork from.")
+          return nil
+        end
+
+        point = select_fork_point_from_points(points)
+        return nil unless point
+
+        run_busy_local_command_and_requeue(activity: "forking") do
+          fork_session_from_point(session_store, point)
+        end
+      rescue StandardError => e
+        runtime_output("Fork error: #{e.message}")
+        nil
+      end
+
+      def fork_points(session_store)
+        fork_points_for_session(session_store, @active_session)
+      end
+
+      def fork_points_for_session(session_store, session)
+        entries = session_store.session_entries(session.path)
+        current_leaf_id = session.leaf_id || session_store.current_leaf(session.path)
+        active_path = active_session_tree_entry_ids(entries, current_leaf_id)
+        entries.each_with_index.filter_map do |entry, index|
+          next unless rewind_entry?(entry)
+          next unless active_path.include?(entry["id"].to_s)
+
+          {
+            entry: entry,
+            entry_index: index,
+            label: fork_point_label(entry),
+            timestamp: entry["timestamp"]
+          }
+        end.reverse.then { |points| align_rewind_point_timestamps(points, picker_choice_width) }
+      end
+
+      def fork_point_label(entry)
+        "Fork from: #{truncate_rewind_text(full_message_text(entry["message"] || {}))}"
+      end
+
+      def select_fork_point(labels)
+        if @prompt.respond_to?(:select)
+          return @prompt.select("Fork>", labels, title: "Fork")
+        end
+
+        numbered_labels = labels.each_with_index.map { |label, index| "#{index + 1}. #{label}" }
+        runtime_output((["Fork from:"] + numbered_labels).join("\n"))
+        answer = @prompt.ask("Fork point number>").to_s.strip
+        answer.match?(/\A\d+\z/) ? labels[answer.to_i - 1] : nil
+      end
+
+      def fork_session_from_point(session_store, point)
+        previous_session = @active_session
+        forked_session, conversation, selected_text = create_fork_from_point(session_store, previous_session, point)
+        @active_session = track_session(forked_session)
+        reset_session_diff(@active_session.path)
+        cleanup_replaced_session(previous_session)
+        update_assistant_prompt(conversation)
+        restore_prompt_transcript do
+          runtime_output("Forked session: #{@active_session.path}")
+          render_conversation_transcript(conversation)
+        end
+        prefill_selected_fork_text(selected_text)
+        agent = build_interactive_agent(conversation)
+        @prompt.redraw if @prompt.respond_to?(:redraw) && !@prompt.respond_to?(:restore_transcript)
+        agent
+      end
+
+      def create_fork_from_point(session_store, source_session, point)
+        entries = session_store.session_entries(source_session.path)
+        messages = entries[0...point[:entry_index]].filter_map { |entry| entry["message"] }
+        forked_session, conversation = session_store.create_independent_from_messages(
+          messages,
+          provider: current_model_provider,
+          model: current_model_id,
+          reasoning_effort: current_reasoning_effort,
+          parent_session: source_session
+        )
+        [forked_session, conversation, full_message_text(point[:entry]["message"] || {})]
+      end
+
+      def prefill_selected_fork_text(selected_text)
+        return if selected_text.to_s.empty?
+
+        if @prompt.respond_to?(:prefill_input)
+          @prompt.prefill_input(selected_text)
+        else
+          runtime_output("Selected prompt for editing:\n#{selected_text}")
+        end
+      end
+
+      def clone_session_from_path(session_store, path)
+        clone_path = clone_session_file_from_path(session_store, path)
+        load_session(session_store, clone_path, message: "Cloned session")
+      end
+
+      def fork_session_from_picker(session_store, source_path)
+        source_session, = session_store.load(source_path, workspace: configured_workspace(root: session_store.cwd), provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort)
+        point = select_fork_point_for_session(session_store, source_session)
+        return nil unless point
+
+        forked_session, = create_fork_from_point(session_store, source_session, point)
+        forked_session.path
+      end
+
+      def select_fork_point_for_session(session_store, session)
+        points = fork_points_for_session(session_store, session)
+        if points.empty?
+          runtime_output("No prompts to fork from.")
+          return nil
+        end
+
+        select_fork_point_from_points(points)
+      end
+
+      def select_fork_point_from_points(points)
+        labels = points.map { |point| point[:label] }
+        choice = select_fork_point(labels)
+        return nil unless choice
+
+        points[labels.index(choice)]
+      end
+
+      def clone_session_file_from_path(session_store, path)
+        source_session, source_conversation = session_store.load(path, workspace: configured_workspace(root: session_store.cwd), provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort)
+        clone, = session_store.create_independent_from_conversation(source_conversation, parent_session: source_session)
+        clone.path
+      end
+
+      def clone_session_selection(session_store, sessions, labels, label)
+        copy_session_selection(session_store, sessions, labels, label) do |source|
+          clone_session_file_from_path(session_store, source.path)
+        end
+      end
+
+      def copy_session_selection(session_store, sessions, labels, label)
+        source = sessions[labels.index(label)]
+        return nil unless source
+
+        copy_path = yield source
+        insert_session_copy(session_store, sessions, labels, source, copy_path)
+      end
+
+      def insert_session_copy(session_store, sessions, labels, source, copy_path)
+        copy_info = session_store.recent_tree(limit: nil).find { |session| File.expand_path(session.path) == File.expand_path(copy_path) }
+        copy_info ||= session_store.recent(limit: nil).find { |session| File.expand_path(session.path) == File.expand_path(copy_path) }
+        return nil unless copy_info
+
+        source_index = sessions.index(source) || 0
+        copy_index = source_index + 1
+        sessions.insert(copy_index, copy_info)
+        labels.replace(session_picker_labels(sessions))
+        continue_session_selection(labels, copy_index)
+      end
+
+      def delete_session_selection(_session_store, sessions, labels, label)
+        source = sessions[labels.index(label)]
+        return nil unless source
+
+        SessionTrash.new.delete(source.path)
+        index = sessions.index(source) || labels.index(label) || 0
+        sessions.delete_at(index)
+        labels.replace(session_picker_labels(sessions))
+        next_index = [index, labels.length - 1].min
+        continue_session_selection(labels, next_index)
+      end
+
+      def rename_session_selection(session_store, sessions, labels, label, name)
+        source = sessions[labels.index(label)]
+        return nil unless source
+
+        session_store.load(source.path).first.rename(name)
+        updated = session_store.recent_tree(limit: nil)
+        sessions.replace(updated)
+        labels.replace(session_picker_labels(sessions))
+        index = sessions.index { |session| File.expand_path(session.path) == File.expand_path(source.path) } || 0
+        continue_session_selection(labels, index)
+      end
+
+      def continue_session_selection(labels, selection_index)
+        { select_continue: true, choices: labels, selection_index: selection_index }
+      end
+
       def copy_session_text(conversation, argument)
         target = copy_target(argument)
         unless target
@@ -314,16 +703,46 @@ module Kward
       end
 
       def select_session_path(session_store)
-        sessions = session_store.recent(limit: nil)
+        select_session_path_from_sessions(session_store.recent_tree(limit: nil), session_store: session_store)
+      end
+
+      def reopen_sessions_after_fork(session_store, source_path, source_label)
+        fork_path = run_busy_local_command_and_requeue(activity: "forking") do
+          fork_session_from_picker(session_store, source_path)
+        end
+
+        sessions = session_store.recent_tree(limit: nil)
+        labels = session_picker_labels(sessions)
+        initial_index = if fork_path
+                          sessions.index { |session| File.expand_path(session.path) == File.expand_path(fork_path) }
+                        else
+                          labels.index(source_label)
+                        end
+        select_session_path_from_sessions(sessions, session_store: session_store, initial_index: initial_index || 0)
+      end
+
+      def select_session_path_from_sessions(sessions, session_store: @session_store, initial_index: 0)
         if sessions.empty?
           runtime_output("No saved sessions found.")
           return nil
         end
 
-        labels = sessions.map { |session| session_label(session) }
+        labels = session_picker_labels(sessions)
         if @prompt.respond_to?(:select)
-          choice = @prompt.select("Session>", labels)
+          choice = @prompt.select(
+            "Session>",
+            labels,
+            initial_index: initial_index,
+            action_keys: { "c" => { action: :clone, activity: "cloning" }, "f" => { action: :fork, defer_finish_render: true }, "r" => { action: :rename, input_prompt: "Name>" }, "d" => { action: :delete, confirm: "Press d again to delete, Esc to cancel.", confirm_title: "Delete session?" } },
+            action_handlers: {
+              clone: ->(label) { clone_session_selection(session_store, sessions, labels, label) },
+              delete: ->(label) { delete_session_selection(session_store, sessions, labels, label) },
+              rename: ->(label, name) { rename_session_selection(session_store, sessions, labels, label, name) }
+            }
+          )
           return nil unless choice
+          return choice if choice.respond_to?(:conversation)
+          return choice[:path] ? choice : session_selection_action(choice, sessions, labels, defer_finish_render: choice[:defer_finish_render]) if choice.is_a?(Hash)
 
           selected = sessions[labels.index(choice)]
           return selected&.path
@@ -339,6 +758,26 @@ module Kward
         end
       end
 
+      def session_selection_action(choice, sessions, labels, defer_finish_render: false)
+        selected = sessions[labels.index(choice[:choice])]
+        return nil unless selected
+
+        { action: choice[:action], path: selected.path, choice_label: choice[:choice] }.tap do |action|
+          action[:defer_finish_render] = true if defer_finish_render
+        end
+      end
+
+      def session_picker_labels(sessions)
+        labels = sessions.map { |session| session_label(session) }
+        label_width = labels.map(&:length).max.to_i
+        sessions.zip(labels).map do |session, label|
+          timestamp = relative_rewind_time(session.modified_at)
+          next label if timestamp.empty?
+
+          right_aligned_picker_metadata(label, timestamp, width: picker_choice_width, minimum_label_width: label_width)
+        end
+      end
+
       def session_label(session)
         title = session.name.to_s.strip
         title = session.first_message.to_s.strip if title.empty?

data/lib/kward/cli/settings.rb

@@ -222,9 +222,6 @@ module Kward
         when /\Ashow busy help/, /\Ahide busy help/
           set_composer_busy_help(!composer_busy_help?)
           runtime_output("Busy help #{composer_busy_help? ? "enabled" : "disabled"}. Restart the TUI to apply this setting.")
-        when /\Ashow startup banner/, /\Ahide startup banner/
-          set_banner_enabled(!banner_enabled?)
-          runtime_output("Startup banner #{banner_enabled? ? "enabled" : "disabled"}. Restart the TUI to apply this setting.")
         when /\Aenable session auto-resume/, /\Adisable session auto-resume/
           set_session_auto_resume_enabled(!session_auto_resume_enabled?)
           runtime_output("Session auto-resume #{session_auto_resume_enabled? ? "enabled" : "disabled"}.")
@@ -237,7 +234,6 @@ module Kward
           "Overlay alignment (#{settings["alignment"]})",
           "Overlay width (#{settings["width"]})",
           "#{composer_busy_help? ? "Hide" : "Show"} busy help (currently #{on_off(composer_busy_help?)})",
-          "#{banner_enabled? ? "Hide" : "Show"} startup banner (currently #{on_off(banner_enabled?)})",
           "#{session_auto_resume_enabled? ? "Disable" : "Enable"} session auto-resume (currently #{on_off(session_auto_resume_enabled?)})",
           "Back"
         ]
@@ -247,10 +243,6 @@ module Kward
         ConfigFiles.composer_busy_help?(safely_read_config.to_h)
       end
 
-      def banner_enabled?
-        ConfigFiles.banner_enabled?(safely_read_config.to_h)
-      end
-
       def session_auto_resume_enabled?
         ConfigFiles.session_auto_resume_enabled?(safely_read_config.to_h)
       end
@@ -259,10 +251,6 @@ module Kward
         update_nested_config("composer", "busy_help" => enabled)
       end
 
-      def set_banner_enabled(enabled)
-        update_nested_config("banner", "enabled" => enabled)
-      end
-
       def set_session_auto_resume_enabled(enabled)
         update_nested_config("sessions", "auto_resume" => enabled)
       end
@@ -518,24 +506,6 @@ module Kward
         runtime_output("Model error: #{e.message}")
       end
 
-      # Writes the openrouter catalog output for the terminal CLI flow.
-      def print_openrouter_catalog
-        unless @client.respond_to?(:openrouter_catalog)
-          runtime_output("OpenRouter catalog is unavailable for this client.")
-          return
-        end
-
-        models = Array(@client.openrouter_catalog)
-        if models.empty?
-          runtime_output("No OpenRouter catalog models available.")
-        else
-          ids = models.map { |model| model[:id] || model["id"] || model }.map(&:to_s).reject(&:empty?)
-          runtime_output((["OpenRouter catalog:"] + ids).join("\n"))
-        end
-      rescue StandardError => e
-        runtime_output("OpenRouter catalog error: #{e.message}")
-      end
-
       def configure_reasoning(conversation = nil)
         unless model_overlay_available?
           runtime_output("Reasoning overlay is unavailable in this prompt.")

data/lib/kward/cli/slash_commands.rb

@@ -32,9 +32,6 @@ module Kward
           models = run_busy_local_command_and_requeue { normalized_available_models }
           configure_model(agent.conversation, models: models)
           [true, nil]
-        when "openrouter/catalog"
-          run_busy_local_command_and_requeue { print_openrouter_catalog }
-          [true, nil]
         when "reasoning"
           configure_reasoning(agent.conversation)
           [true, nil]
@@ -43,19 +40,49 @@ module Kward
           [true, nil]
         when "new"
           [true, run_busy_local_command_and_requeue { start_new_session(session_store) }]
-        when "resume"
-          [true, run_busy_local_command_and_requeue do
-            path = argument.to_s.strip
-            path = select_session_path(session_store) if session_store && path.empty?
-            resume_session(session_store, path)
-          end]
+        when "sessions", "resume"
+          unless session_store
+            say_sessions_unavailable
+            return [true, nil]
+          end
+
+          path = argument.to_s.strip
+          if path.empty?
+            sessions = run_busy_local_command_and_requeue { session_store.recent_tree(limit: nil) }
+            path = select_session_path_from_sessions(sessions, session_store: session_store)
+          end
+          replacement_agent = nil
+          selection = path
+          loop do
+            replacement_agent = if selection.respond_to?(:conversation)
+                                  selection
+                                elsif selection.is_a?(Hash) && selection[:action] == :clone
+                                  run_busy_local_command_and_requeue(activity: "cloning") { clone_session_from_path(session_store, selection[:path]) }
+                                elsif selection.is_a?(Hash) && selection[:action] == :fork
+                                  selection = reopen_sessions_after_fork(session_store, selection[:path], selection[:choice_label])
+                                  next
+                                elsif selection.to_s.empty?
+                                  nil
+                                else
+                                  run_busy_local_command_and_requeue { resume_session(session_store, selection) }
+                                end
+            break
+          end
+          [true, replacement_agent]
         when "name"
-          run_busy_local_command_and_requeue { rename_session(argument) }
+          rename_session(argument)
+          [true, nil]
+        when "rename"
+          rename_session(argument, require_name: true)
           [true, nil]
         when "clone"
           [true, run_busy_local_command_and_requeue { clone_session(session_store, agent) }]
+        when "fork"
+          [true, fork_session(session_store)]
+        when "rewind"
+          [true, run_busy_local_command_and_requeue { rewind_session(session_store) }]
         when "tree"
-          [true, run_busy_local_command_and_requeue { navigate_session_tree(session_store) }]
+          [true, navigate_session_tree(session_store)]
         when "copy"
           run_busy_local_command_and_requeue { copy_session_text(agent.conversation, argument) }
           [true, nil]