kward 0.70.0 → 0.71.0

data/lib/kward/cli/commands.rb

@@ -53,6 +53,7 @@ module Kward
             #{command.call("kward init")}                         Install starter prompts and PRINCIPLES.md
             #{command.call("kward doctor")}                       Check local Kward setup
             #{command.call("kward sysprompt")}                    Inspect the effective system prompt
+            #{command.call("kward openrouter refresh")}           Refresh cached OpenRouter models
             #{command.call("kward pan")}                          Start Pan mode web UI
             #{command.call("kward rpc")}                          Start the experimental JSON-RPC backend
 
@@ -65,6 +66,7 @@ module Kward
             #{command.call("doctor")}                             Check local Kward setup
             #{command.call("sysprompt")} [--raw]                  Inspect the effective system prompt
             #{command.call("stats tokens")} [range] [options]      Export local token telemetry as CSV
+            #{command.call("openrouter refresh|list")}             Refresh or list cached OpenRouter models
             #{command.call("pan")}                                Start Pan mode web UI
             #{command.call("rpc")}                                Run the JSON-RPC backend for UI clients
 
@@ -78,6 +80,7 @@ module Kward
             #{command.call("kward")} #{option.call('"Review this diff"')}
             #{command.call("git diff | kward")} #{option.call('"Review this diff"')}
             #{command.call("kward login openrouter")}
+            #{command.call("kward openrouter refresh")}
             #{command.call("kward stats tokens today --bucket hour")}
 
           Command names take precedence. Anything else is sent as a one-shot prompt.
@@ -126,6 +129,11 @@ module Kward
             description: "Export local token telemetry as CSV.",
             examples: ["kward stats tokens today", "kward stats tokens today --bucket hour", "kward stats tokens week --output tokens.csv"]
           },
+          "openrouter" => {
+            usage: "kward openrouter refresh|list",
+            description: "Refresh or list cached text-capable OpenRouter models available to your API key.",
+            examples: ["kward openrouter refresh", "kward openrouter --refresh", "kward openrouter list"]
+          },
           "pan" => {
             usage: "kward pan",
             description: "Start Pan mode, a minimal LAN web UI with a prompt textarea and transcript.",

data/lib/kward/cli/openrouter_commands.rb

@@ -0,0 +1,55 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
+  class CLI
+    # OpenRouter cache management commands for the terminal CLI flow.
+    module OpenRouterCommands
+      private
+
+      def handle_openrouter_command(arguments)
+        case arguments
+        when ["refresh"], ["--refresh"]
+          refresh_openrouter_models
+        when ["list"], ["--list"]
+          list_openrouter_models
+        else
+          raise ArgumentError, command_usage("openrouter")
+        end
+      end
+
+      def refresh_openrouter_models
+        cache = OpenRouterModelCache.new(api_key: configured_openrouter_api_key, path: openrouter_models_cache_path)
+        data = cache.refresh
+        count = Array(data["models"]).length
+        @client.reload_config if @client.respond_to?(:reload_config)
+        @prompt.say("Refreshed #{count} OpenRouter text model#{count == 1 ? "" : "s"} for this key.")
+        @prompt.say("Cached at: #{cache.path}")
+      rescue StandardError => e
+        warn e.message
+        exit 1
+      end
+
+      def list_openrouter_models
+        cache = OpenRouterModelCache.new(api_key: configured_openrouter_api_key, path: openrouter_models_cache_path)
+        data = cache.read
+        unless data
+          @prompt.say("No OpenRouter model cache found. Run `kward openrouter refresh` first.")
+          return
+        end
+
+        models = Array(data["models"])
+        lines = ["OpenRouter models cached at #{data["refreshed_at"]}:"]
+        lines.concat(models.map { |model| model["id"].to_s }.reject(&:empty?))
+        @prompt.say(lines.join("\n"))
+      end
+
+      def configured_openrouter_api_key
+        ENV["OPENROUTER_API_KEY"].to_s.empty? ? ConfigFiles.config_value(ConfigFiles.read_config, "openrouter_api_key").to_s : ENV["OPENROUTER_API_KEY"].to_s
+      end
+
+      def openrouter_models_cache_path
+        File.join(File.dirname(ConfigFiles.config_path), "cache", "openrouter_models.json")
+      end
+    end
+  end
+end

data/lib/kward/cli/prompt_interface.rb

@@ -1,3 +1,5 @@
+require "open3"
+
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
@@ -13,7 +15,6 @@ module Kward
         prompt_interface = load_prompt_interface
         return unless prompt_interface
 
-        banner_enabled = ConfigFiles.banner_enabled?
         @prompt = prompt_interface.new(
           slash_commands: slash_command_entries,
           overlay_settings: ConfigFiles.overlay_settings,
@@ -22,8 +23,7 @@ module Kward
           busy_help: ConfigFiles.composer_busy_help?,
           attachment_badges: method(:composer_attachment_badges),
           attachment_parser: method(:composer_attachment_parser),
-          banner_pixels: banner_enabled ? Kward::PromptInterface::BANNER_LOGO_PIXELS : nil,
-          banner_message: banner_enabled ? Kward::PromptInterface::BANNER_MESSAGE : nil
+          banner_message: Kward::PromptInterface::BANNER_MESSAGE
         )
         if @prompt.method(:start).parameters.any? { |kind, name| [:key, :keyreq].include?(kind) && name == :render }
           @prompt.start(render: false)
@@ -50,9 +50,80 @@ module Kward
         @prompt.respond_to?(:start_stream_block) && @prompt.respond_to?(:write_delta)
       end
 
-      # Writes the visual banner output for the terminal CLI flow.
+      # Writes the startup info screen output for the terminal CLI flow.
       def print_visual_banner
-        @prompt.print_visual_banner if @prompt.respond_to?(:print_visual_banner)
+        return unless @prompt.respond_to?(:print_visual_banner)
+
+        @prompt.print_visual_banner(startup_info_screen)
+      end
+
+      def startup_info_screen
+        [
+          startup_status_line,
+          "",
+          startup_info_line("Workspace", startup_workspace_label),
+          startup_info_line("Branch", startup_branch_value),
+          startup_info_line("Plugins", startup_plugins_value),
+          "",
+          startup_brand_line
+        ].join("\n")
+      end
+
+      def startup_workspace_label
+        root = File.expand_path(current_workspace_root)
+        home = begin
+          Dir.home
+        rescue StandardError
+          nil
+        end
+        if home && (root == home || root.start_with?("#{home}/"))
+          relative = root.delete_prefix(home).sub(%r{\A/}, "")
+          return "~" if relative.empty?
+          return "~/#{relative}" unless relative.include?("/")
+        end
+
+        parent = File.basename(File.dirname(root))
+        name = File.basename(root)
+        parent.empty? || parent == "." ? name : "#{parent}/#{name}"
+      end
+
+      def startup_branch_value
+        git_root = startup_git_root(current_workspace_root)
+        return "not a repository" if git_root.to_s.empty?
+
+        branch = startup_git_output(%w[git branch --show-current], root: git_root)
+        branch = startup_git_output(%w[git rev-parse --short HEAD], root: git_root) if branch.empty?
+        branch.empty? ? "unknown" : branch
+      end
+
+      def startup_plugins_value
+        filenames = plugin_registry.paths.map { |path| File.basename(path) }
+        filenames.empty? ? "none" : filenames.join(", ")
+      end
+
+      def startup_status_line
+        "#{ANSI.colorize("●", :green, enabled: @color_enabled)} Kward v#{Kward::VERSION} is online."
+      end
+
+      def startup_info_line(label, value)
+        "#{ANSI.colorize(label.ljust(12), :gray, enabled: @color_enabled)}#{ANSI.colorize(value, :cyan, enabled: @color_enabled)}"
+      end
+
+      def startup_brand_line
+        ANSI.colorize(Kward::PromptInterface::BANNER_MESSAGE, :bold, enabled: @color_enabled)
+      end
+
+      def startup_git_root(root)
+        startup_git_output(%w[git rev-parse --show-toplevel], root: root)
+      end
+
+      def startup_git_output(command, root:)
+        output, status = Open3.capture2e(*command, chdir: root.to_s)
+        return "" unless status.success?
+
+        output.lines.first.to_s.strip
+      rescue StandardError
+        ""
       end
 
       def prompt_footer_renderer
@@ -107,7 +178,10 @@ module Kward
       def composer_context_window(provider = nil, model = nil)
         provider ||= current_footer_conversation.provider || (@client.respond_to?(:current_provider) ? @client.current_provider : "Codex")
         model ||= current_footer_conversation.model || (@client.respond_to?(:current_model) ? @client.current_model : ModelInfo::DEFAULT_OPENAI_MODEL)
-        ModelInfo.context_window(ModelInfo.provider_label(provider), model)
+        provider = ModelInfo.provider_label(provider)
+        return @client.context_window(provider, model) if @client.respond_to?(:context_window) && @client.method(:context_window).arity != 0
+
+        ModelInfo.context_window(provider, model)
       end
 
       def composer_context_usage(provider, model)

data/lib/kward/cli/rendering.rb

@@ -59,7 +59,7 @@ module Kward
         if prompt_interface?
           print_tool_result(tool_call, content, line_limit: INTERACTIVE_TOOL_OUTPUT_LINE_LIMIT)
         else
-          @prompt.say("\n#{colored("Tool>", *tool_label_styles(content))}\n#{summary}\n")
+          @prompt.say("\n#{colored("Tool>", *tool_label_styles(content))} #{tool_summary_display_text(summary)}\n")
         end
       end
 
@@ -71,7 +71,7 @@ module Kward
           print_block_delta(label, rendered)
           finish_stream_block
         else
-          @prompt.say("\n#{colored("#{transcript_label(label)}>", *label_styles(label))}\n#{rendered}\n")
+          @prompt.say("\n#{colored("#{transcript_label(label)}>", *label_styles(label))} #{rendered}\n")
         end
       end
 
@@ -298,8 +298,9 @@ module Kward
       def print_tool_result(tool_call, content, line_limit: nil)
         summary = tool_result_summary(tool_call, content)
         summary = limit_tool_output_lines(summary, line_limit) if line_limit
+        display_summary = tool_summary_display_text(summary)
         if prompt_interface?
-          summary = summary.end_with?("\n") ? summary : "#{summary}\n"
+          summary = display_summary.end_with?("\n") ? display_summary : "#{display_summary}\n"
           if @prompt.respond_to?(:write_stream_block)
             @prompt.write_stream_block("Tool", summary, finish: true)
           else
@@ -309,18 +310,22 @@ module Kward
           end
         else
           start_stream_block(tool_stream_label(content))
-          print summary
-          puts unless summary.end_with?("\n")
+          print display_summary
+          puts unless display_summary.end_with?("\n")
           $stdout.flush
           @stream_block = nil
         end
       end
 
+      def tool_summary_display_text(summary)
+        summary.to_s.sub("\n", "\n\n")
+      end
+
       def start_stream_block(label)
         return if @stream_block == label
 
         puts if @stream_block
-        puts "\n#{colored("#{transcript_label(label)}>", *label_styles(label))}"
+        print "\n#{colored("#{transcript_label(label)}>", *label_styles(label))} "
         @stream_block = label
       end
 

data/lib/kward/cli/sessions.rb

@@ -108,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)
@@ -115,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)
@@ -295,7 +299,7 @@ module Kward
       end
 
       def relative_rewind_time(timestamp)
-        time = Time.iso8601(timestamp.to_s).utc
+        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
@@ -397,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
@@ -420,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
@@ -501,19 +703,46 @@ module Kward
       end
 
       def select_session_path(session_store)
-        select_session_path_from_sessions(session_store.recent_tree(limit: nil))
+        select_session_path_from_sessions(session_store.recent_tree(limit: nil), session_store: session_store)
       end
 
-      def select_session_path_from_sessions(sessions)
+      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
@@ -529,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.")