kward 0.66.0 → 0.67.0

data/lib/kward/cli.rb

@@ -1,13 +1,15 @@
-require "base64"
+require "fileutils"
 require "json"
 require "thread"
 require "tty-prompt"
 require_relative "agent"
 require_relative "ansi"
+require_relative "version"
 require_relative "model/client"
 require_relative "compactor"
 require_relative "config_files"
 require_relative "clipboard"
+require_relative "cli_transcript_formatter"
 require_relative "model/context_usage"
 require_relative "events"
 require_relative "export_path"
@@ -26,6 +28,7 @@ require_relative "model/retry_message"
 require_relative "rpc/server"
 require_relative "session_diff"
 require_relative "session_store"
+require_relative "session_tree_renderer"
 require_relative "starter_pack_installer"
 require_relative "steering"
 require_relative "tools/tool_call"
@@ -57,6 +60,8 @@ module Kward
       @session_diff = SessionDiff.new
       @cleanup_sessions = []
       @plugin_registry = nil
+      @working_directory = nil
+      @prompt_delimited = false
       @color_enabled = ANSI.enabled?($stdout)
     end
 
@@ -65,35 +70,117 @@ module Kward
     #
     # @return [void]
     def run
+      @argv = extract_global_options(@argv)
+      with_working_directory { dispatch }
+    rescue ArgumentError => e
+      warn e.message
+      warn "Run `kward help` for available commands."
+      exit 1
+    end
+
+    def dispatch
+      if @prompt_delimited
+        ConfigFiles.ensure_default_config!
+        run_prompt_or_interactive
+        return
+      end
+
+      if help_command?
+        print_command_help(@argv[1])
+        return
+      end
+      raise ArgumentError, command_usage("help") if ["help", "--help", "-h"].include?(@argv.first)
+
+      if version_command?
+        print_version
+        return
+      end
+      raise ArgumentError, command_usage("version") if ["version", "--version", "-v"].include?(@argv.first)
+
       ConfigFiles.ensure_default_config!
 
+      if @argv.first == "init"
+        if help_option_arguments?(@argv[1..] || [])
+          print_command_help("init")
+          return
+        end
+        raise ArgumentError, command_usage("init") unless @argv.length == 1
+
+        install_starter_pack
+        return
+      end
+
       if @argv == ["--install-starter-pack"]
         install_starter_pack
         return
       end
 
-      if @argv.first == "rpc" && @argv.length == 1
+      if @argv.first == "auth"
+        handle_auth_command(@argv[1..] || [])
+        return
+      end
+
+      if @argv.first == "doctor"
+        if help_option_arguments?(@argv[1..] || [])
+          print_command_help("doctor")
+          return
+        end
+        raise ArgumentError, command_usage("doctor") unless @argv.length == 1
+
+        print_doctor
+        return
+      end
+
+      if @argv.first == "rpc"
+        if help_option_arguments?(@argv[1..] || [])
+          print_command_help("rpc")
+          return
+        end
+        raise ArgumentError, command_usage("rpc") unless @argv.length == 1
+
         Kward::RPC::Server.new(input: @stdin, output: $stdout, client: @client).run
         return
       end
 
-      if @argv[0, 2] == ["stats", "tokens"]
+      if @argv.first == "stats"
+        if @argv[1] == "tokens" && help_option_arguments?(@argv[2..] || [])
+          print_command_help("stats")
+          return
+        end
+        raise ArgumentError, command_usage("stats") unless @argv[1] == "tokens"
+
         export_token_stats(@argv[2..] || [])
         return
       end
 
       if pan_mode?
-        PanServer.new(client: @client, working_directory: pan_working_directory).run
+        if help_option_arguments?(@argv[1..] || [])
+          print_command_help("pan")
+          return
+        end
+        raise ArgumentError, command_usage("pan") unless @argv.length == 1
+
+        PanServer.new(client: @client, working_directory: current_workspace_root).run
         return
       end
 
-      if ["login", "--login"].include?(@argv.first) && @argv.length <= 2
+      if ["login", "--login"].include?(@argv.first)
+        if help_option_arguments?(@argv[1..] || [])
+          print_command_help("login")
+          return
+        end
+        raise ArgumentError, command_usage("login") unless @argv.length <= 2
+
         login(provider: @argv[1])
         return
       end
 
-      first_prompt = @argv.join(" ").strip
-      unless first_prompt.empty?
+      run_prompt_or_interactive
+    end
+
+    def run_prompt_or_interactive
+      first_prompt = one_shot_prompt_argument
+      if first_prompt
         answer = one_shot(first_prompt)
         puts answer unless answer.empty?
         return
@@ -116,7 +203,7 @@ module Kward
       conversation = new_conversation
       agent = Agent.new(
         client: @client,
-        tool_registry: ToolRegistry.new(prompt: @prompt),
+        tool_registry: ToolRegistry.new(workspace: configured_workspace, prompt: @prompt),
         conversation: conversation
       )
       answer = agent.ask(input) do |event|
@@ -146,6 +233,54 @@ module Kward
       assistant_streamed ? "" : render_markdown_transcript(answer)
     end
 
+    def handle_auth_command(arguments)
+      if help_option_arguments?(arguments)
+        print_command_help("auth")
+        return
+      end
+
+      case arguments
+      when ["status"]
+        print_auth_status
+      when ["logout"]
+        logout_auth
+      else
+        raise ArgumentError, command_usage("auth")
+      end
+    end
+
+    def print_auth_status
+      config = safely_read_config.to_h
+      lines = ["#{colored("Auth Status", :green, :bold)}", ""]
+      lines << auth_status_line("OpenAI OAuth", File.exist?(OpenAIOAuth.default_auth_path), OpenAIOAuth.default_auth_path)
+      lines << auth_status_line("GitHub OAuth", File.exist?(GithubOAuth.default_auth_path), GithubOAuth.default_auth_path)
+      lines << auth_status_line("OpenRouter API key", !config["openrouter_api_key"].to_s.empty? || !ENV["OPENROUTER_API_KEY"].to_s.empty?, ConfigFiles.config_path)
+      @prompt.say lines.join("\n")
+    end
+
+    def auth_status_line(label, configured, location)
+      status = configured ? :ok : :warning
+      message = configured ? "configured" : "not configured"
+      "#{doctor_mark(status)} #{label}: #{message} (#{location})"
+    end
+
+    def logout_auth
+      removed = []
+      [OpenAIOAuth.default_auth_path, GithubOAuth.default_auth_path].each do |path|
+        next unless File.exist?(path)
+
+        File.delete(path)
+        removed << path
+      end
+      removed << "OpenRouter API key" if OpenRouterAPIKey.new.logout
+
+      if removed.empty?
+        @prompt.say "No saved credentials found."
+      else
+        @prompt.say "Removed #{removed.length} saved credential#{removed.length == 1 ? "" : "s"}."
+      end
+    end
+
     def login(provider: nil, oauth: nil)
       provider = provider.to_s.downcase
       if provider == "openrouter"
@@ -164,12 +299,9 @@ module Kward
     def interactive_loop(agent: nil)
       setup_interactive_prompt
       session_store = interactive_session_store(agent)
+      @resumed_last_session = false
       if session_store && agent.nil?
-        @active_session = track_session(session_store.create(model: current_model_id, reasoning_effort: current_reasoning_effort))
-        reset_session_diff
-        conversation = new_conversation(workspace_root: session_store.cwd)
-        @active_session.attach(conversation)
-        agent = build_interactive_agent(conversation)
+        agent = resume_last_session(session_store) || build_new_session_agent(session_store)
       elsif session_store
         @active_session = track_session(session_store.create(model: current_model_id, reasoning_effort: current_reasoning_effort))
         reset_session_diff
@@ -181,7 +313,8 @@ module Kward
       update_assistant_prompt(agent.conversation)
       @footer_conversation = agent.conversation
 
-      print_visual_banner
+      print_visual_banner unless @resumed_last_session
+      render_resumed_last_session_transcript(agent.conversation) if @resumed_last_session
 
       @pending_inputs = []
 
@@ -207,12 +340,14 @@ module Kward
           agent = replacement_agent if replacement_agent
         end
         next if handled
+        next if shell_command_input?(command_input) && handle_interactive_shell_command(command_input, agent)
 
         expanded_input = expand_prompt_template(input)
         display_input = display_input || input if expanded_input
         input = expanded_input || input
         @footer_conversation = agent.conversation
         begin
+          auto_name_active_session(display_input || input)
           pending_inputs = run_interactive_turn(agent, input, display_input: display_input)
           pending_inputs.reverse_each { |pending_input| @pending_inputs.unshift(pending_input) }
         rescue StandardError => e
@@ -229,6 +364,7 @@ module Kward
         @prompt.close if prompt_interface?
       ensure
         cleanup_unused_sessions
+        remember_active_session(session_store)
       end
     end
 
@@ -240,6 +376,266 @@ module Kward
 
     private
 
+    def help_command?
+      ["help", "--help", "-h"].include?(@argv.first) && @argv.length <= 2
+    end
+
+    def version_command?
+      ["version", "--version", "-v"].include?(@argv.first) && @argv.length == 1
+    end
+
+    def help_option_arguments?(arguments)
+      arguments.length == 1 && ["help", "--help", "-h"].include?(arguments.first)
+    end
+
+    def one_shot_prompt_argument
+      prompt = @argv.join(" ").strip
+      prompt.empty? ? nil : prompt
+    end
+
+    def print_command_help(command_name = nil)
+      if command_name.to_s.empty? || ["--help", "-h"].include?(command_name)
+        print_help
+        return
+      end
+
+      help = command_help[command_name]
+      raise ArgumentError, "Unknown command: #{command_name}" unless help
+
+      @prompt.say render_command_help(command_name, help)
+    end
+
+    def print_help
+      command = ->(text) { colored(text, :green, :bold) }
+      option = ->(text) { colored(text, :cyan) }
+      heading = ->(text) { colored(text, :blue, :bold) }
+
+      @prompt.say <<~HELP.rstrip
+        #{colored("Kward", :green, :bold)} - an extendable CLI coding agent
+
+        #{heading.call("Usage")}
+          #{command.call("kward")}                              Start an interactive chat
+          #{command.call("kward")} #{option.call('"Explain this project"')}       Run a one-shot prompt
+          #{command.call("kward login")}                        Sign in or save provider credentials
+          #{command.call("kward auth status")}                  Show saved credential status
+          #{command.call("kward init")}                         Install starter prompts and AGENTS.md
+          #{command.call("kward doctor")}                       Check local Kward setup
+          #{command.call("kward pan")}                          Start Pan mode web UI
+          #{command.call("kward rpc")}                          Start the experimental JSON-RPC backend
+
+        #{heading.call("Commands")}
+          #{command.call("help")}                               Show this help
+          #{command.call("version")}                            Show the installed Kward version
+          #{command.call("login")} [openrouter|github]           Sign in with OpenAI, OpenRouter, or GitHub
+          #{command.call("auth status|logout")}                 Show or clear saved credentials
+          #{command.call("init")}                               Install starter prompts and AGENTS.md
+          #{command.call("doctor")}                             Check local Kward setup
+          #{command.call("stats tokens")} [range] [options]      Export local token telemetry as CSV
+          #{command.call("pan")}                                Start Pan mode web UI
+          #{command.call("rpc")}                                Run the JSON-RPC backend for UI clients
+
+        #{heading.call("Options")}
+          #{option.call("--working-directory=PATH")}             Run Kward from PATH
+          #{option.call("--help")}, #{option.call("-h")}                         Show this help
+          #{option.call("--version")}, #{option.call("-v")}                      Show the installed version
+
+        #{heading.call("Examples")}
+          #{command.call("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 stats tokens today --bucket hour")}
+
+        Command names take precedence. Anything else is sent as a one-shot prompt.
+      HELP
+    end
+
+    def command_help
+      {
+        "help" => {
+          usage: "kward help [command]",
+          description: "Show the top-level command overview or help for one command.",
+          examples: ["kward help", "kward help pan"]
+        },
+        "version" => {
+          usage: "kward version",
+          description: "Show the installed Kward version.",
+          examples: ["kward version", "kward --version"]
+        },
+        "login" => {
+          usage: "kward login [openrouter|github]",
+          description: "Sign in with OpenAI, OpenRouter, or GitHub.",
+          examples: ["kward login", "kward login openrouter", "kward login github"]
+        },
+        "auth" => {
+          usage: "kward auth status|logout",
+          description: "Show or clear saved provider credentials without printing secrets.",
+          examples: ["kward auth status", "kward auth logout"]
+        },
+        "init" => {
+          usage: "kward init",
+          description: "Install starter prompts and base AGENTS.md into your config directory.",
+          examples: ["kward init"]
+        },
+        "doctor" => {
+          usage: "kward doctor",
+          description: "Check local Kward configuration, workspace, auth hints, and writable directories.",
+          examples: ["kward doctor", "kward --working-directory ~/code/project doctor"]
+        },
+        "stats" => {
+          usage: "kward stats tokens [range] [--bucket second|minute|hour|day|week|month|year] [--output path]",
+          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"]
+        },
+        "pan" => {
+          usage: "kward pan",
+          description: "Start Pan mode, a minimal LAN web UI with a prompt textarea and transcript.",
+          examples: ["kward pan", "kward --working-directory ~/code/project pan"]
+        },
+        "rpc" => {
+          usage: "kward rpc",
+          description: "Start the experimental JSON-RPC backend for UI clients.",
+          examples: ["kward rpc", "kward --working-directory ~/code/project rpc"]
+        }
+      }
+    end
+
+    def render_command_help(name, help)
+      heading = ->(text) { colored(text, :blue, :bold) }
+      command = ->(text) { colored(text, :green, :bold) }
+
+      lines = [
+        "#{command.call(name)} - #{help.fetch(:description)}",
+        "",
+        heading.call("Usage"),
+        "  #{command.call(help.fetch(:usage))}"
+      ]
+      examples = help.fetch(:examples, [])
+      if examples.any?
+        lines << ""
+        lines << heading.call("Examples")
+        examples.each { |example| lines << "  #{command.call(example)}" }
+      end
+      lines.join("\n")
+    end
+
+    def command_usage(name)
+      "Usage: #{command_help.fetch(name).fetch(:usage)}"
+    end
+
+    def print_version
+      @prompt.say "kward #{VERSION}"
+    end
+
+    def print_doctor
+      lines = ["#{colored("Kward Doctor", :green, :bold)}", ""]
+      doctor_checks.each do |check|
+        lines << "#{doctor_mark(check.fetch(:status))} #{check.fetch(:label)}: #{check.fetch(:message)}"
+      end
+      @prompt.say lines.join("\n")
+    end
+
+    def doctor_checks
+      config = safely_read_config
+      [
+        doctor_config_check,
+        doctor_config_json_check(config),
+        doctor_directory_check("Config directory", ConfigFiles.config_dir),
+        doctor_directory_check("Session directory", SessionStore.new(cwd: current_workspace_root).session_dir, create: true),
+        doctor_workspace_check,
+        doctor_model_check,
+        doctor_auth_check(config),
+        doctor_pan_check(config),
+        { status: :ok, label: "Color", message: @color_enabled ? "enabled" : "disabled" }
+      ]
+    end
+
+    def safely_read_config
+      ConfigFiles.read_config
+    rescue StandardError
+      nil
+    end
+
+    def doctor_config_check
+      path = ConfigFiles.config_path
+      if File.exist?(path)
+        readable = File.readable?(path)
+        return { status: readable ? :ok : :error, label: "Config", message: readable ? path : "not readable: #{path}" }
+      end
+
+      { status: :warning, label: "Config", message: "not found: #{path}" }
+    end
+
+    def doctor_config_json_check(config)
+      return { status: :error, label: "Config JSON", message: "invalid or unreadable" } unless config.is_a?(Hash)
+
+      { status: :ok, label: "Config JSON", message: "valid" }
+    end
+
+    def doctor_directory_check(label, path, create: false)
+      FileUtils.mkdir_p(path, mode: 0o700) if create
+      if Dir.exist?(path) && File.writable?(path)
+        { status: :ok, label: label, message: "writable: #{path}" }
+      elsif Dir.exist?(path)
+        { status: :error, label: label, message: "not writable: #{path}" }
+      else
+        { status: :error, label: label, message: "missing: #{path}" }
+      end
+    rescue StandardError => e
+      { status: :error, label: label, message: e.message }
+    end
+
+    def doctor_workspace_check
+      root = current_workspace_root
+      return { status: :ok, label: "Workspace", message: root } if Dir.exist?(root) && File.directory?(root)
+
+      { status: :error, label: "Workspace", message: "not a directory: #{root}" }
+    end
+
+    def doctor_model_check
+      provider = @client.current_provider if @client.respond_to?(:current_provider)
+      model = @client.current_model if @client.respond_to?(:current_model)
+      parts = [provider, model].compact.map(&:to_s).reject(&:empty?)
+      return { status: :ok, label: "Model", message: parts.join(" / ") } if parts.any?
+
+      { status: :warning, label: "Model", message: "not configured" }
+    rescue StandardError => e
+      { status: :warning, label: "Model", message: e.message }
+    end
+
+    def doctor_auth_check(config)
+      openai_auth = OpenAIOAuth.default_auth_path
+      github_auth = GithubOAuth.default_auth_path
+      has_openrouter = !config.to_h["openrouter_api_key"].to_s.empty? || !ENV["OPENROUTER_API_KEY"].to_s.empty?
+      paths = []
+      paths << "OpenAI OAuth" if File.exist?(openai_auth)
+      paths << "GitHub OAuth" if File.exist?(github_auth)
+      paths << "OpenRouter API key" if has_openrouter
+      return { status: :ok, label: "Auth", message: paths.join(", ") } if paths.any?
+
+      { status: :warning, label: "Auth", message: "no saved credentials found; run `kward login`" }
+    end
+
+    def doctor_pan_check(config)
+      pan = config.to_h["pan_mode"] || config.to_h["panMode"] || {}
+      if !pan["username"].to_s.empty? && !pan["password"].to_s.empty?
+        { status: :ok, label: "Pan mode", message: "credentials configured" }
+      else
+        { status: :warning, label: "Pan mode", message: "username/password not configured" }
+      end
+    end
+
+    def doctor_mark(status)
+      case status
+      when :ok
+        colored("✓", :green, :bold)
+      when :warning
+        colored("!", :yellow, :bold)
+      else
+        colored("✗", :red, :bold)
+      end
+    end
+
     def install_starter_pack
       result = StarterPackInstaller.install
       installed_count = result.installed.length
@@ -252,7 +648,7 @@ module Kward
     end
 
     def pan_mode?
-      @argv.include?("--pan-mode")
+      ["pan", "--pan-mode"].include?(@argv.first)
     end
 
     def export_token_stats(arguments)
@@ -299,17 +695,46 @@ module Kward
       { range: remaining.join(" "), bucket: bucket, output: output }
     end
 
-    def pan_working_directory
-      value = option_value("--working-directory")
-      value.to_s.strip.empty? ? Dir.pwd : value
-    end
+    def extract_global_options(arguments)
+      remaining = []
+      index = 0
+      while index < arguments.length
+        argument = arguments[index]
+        case argument
+        when "--"
+          @prompt_delimited = true
+          remaining.concat(arguments[(index + 1)..] || [])
+          break
+        when "--working-directory"
+          index += 1
+          raise ArgumentError, "Missing value for --working-directory" if index >= arguments.length
 
-    def option_value(name)
-      @argv.each_with_index do |argument, index|
-        return argument.split("=", 2).last if argument.start_with?("#{name}=")
-        return @argv[index + 1] if argument == name
+          @working_directory = expanded_working_directory(arguments[index])
+        when /\A--working-directory=(.*)\z/
+          @working_directory = expanded_working_directory(Regexp.last_match(1))
+        else
+          remaining << argument
+        end
+        index += 1
       end
-      nil
+      remaining
+    end
+
+    def expanded_working_directory(path)
+      value = path.to_s.strip
+      raise ArgumentError, "Missing value for --working-directory" if value.empty?
+
+      expanded = File.expand_path(value)
+      raise ArgumentError, "Working directory does not exist: #{expanded}" unless Dir.exist?(expanded)
+      raise ArgumentError, "Working directory is not a directory: #{expanded}" unless File.directory?(expanded)
+
+      expanded
+    end
+
+    def with_working_directory
+      return yield unless @working_directory
+
+      Dir.chdir(@working_directory) { yield }
     end
 
     def interactive_session_store(agent)
@@ -319,6 +744,43 @@ module Kward
       SessionStore.new
     end
 
+    def resume_last_session(session_store)
+      return nil unless session_auto_resume_enabled?
+
+      path = session_store.remembered_last_session_path if session_store.respond_to?(:remembered_last_session_path)
+      return nil if path.to_s.empty?
+
+      @active_session, conversation = session_store.load(path, workspace: configured_workspace(root: session_store.cwd), model: current_model_id, reasoning_effort: current_reasoning_effort)
+      reset_session_diff(@active_session.path)
+      track_session(@active_session)
+      @resumed_last_session = true
+      build_interactive_agent(conversation)
+    rescue StandardError
+      nil
+    end
+
+    def render_resumed_last_session_transcript(conversation)
+      restore_prompt_transcript do
+        @prompt.say("\nResumed session: #{@active_session.path}\n")
+        render_conversation_transcript(conversation)
+      end
+    end
+
+    def remember_active_session(session_store)
+      return unless session_store&.respond_to?(:remember_last_session)
+      return unless @active_session&.path && File.file?(@active_session.path)
+
+      session_store.remember_last_session(@active_session)
+    end
+
+    def build_new_session_agent(session_store)
+      @active_session = track_session(session_store.create(model: current_model_id, reasoning_effort: current_reasoning_effort))
+      reset_session_diff
+      conversation = new_conversation(workspace_root: session_store.cwd)
+      @active_session.attach(conversation)
+      build_interactive_agent(conversation)
+    end
+
     def track_session(session)
       @cleanup_sessions << session if session
       session
@@ -328,12 +790,17 @@ module Kward
       @session_diff = path ? SessionDiff.from_session_file(path) : SessionDiff.new
     end
 
-    def update_session_diff(content)
+    def update_session_diff(content, tool_call: nil)
+      return unless mutation_tool_call?(tool_call)
       return unless @session_diff&.add_tool_result(content)
 
       @prompt.redraw if @prompt.respond_to?(:redraw)
     end
 
+    def mutation_tool_call?(tool_call)
+      ["edit_file", "write_file", "edit", "write"].include?(ToolCall.name(tool_call).to_s)
+    end
+
     def cleanup_unused_sessions
       @cleanup_sessions.reverse_each do |session|
         session.delete_if_unused if session.respond_to?(:delete_if_unused)
@@ -348,7 +815,7 @@ module Kward
       previous_session.delete_if_unused if previous_session.respond_to?(:delete_if_unused)
     end
 
-    def new_conversation(workspace_root: Dir.pwd)
+    def new_conversation(workspace_root: current_workspace_root)
       Conversation.new(workspace_root: workspace_root, model: current_model_id, reasoning_effort: current_reasoning_effort, plugin_registry: plugin_registry)
     end
 
@@ -375,7 +842,7 @@ module Kward
 
     def build_interactive_agent(conversation)
       conversation.plugin_registry ||= plugin_registry if conversation.respond_to?(:plugin_registry)
-      workspace = Workspace.new(root: conversation.workspace_root)
+      workspace = configured_workspace(root: conversation.workspace_root)
       tool_registry = ToolRegistry.new(workspace: workspace, prompt: @prompt)
       @footer_conversation = conversation
       @footer_tool_registry = tool_registry
@@ -386,6 +853,39 @@ module Kward
       )
     end
 
+    def handle_interactive_shell_command(input, agent)
+      command = input.to_s.sub(/\A!\s*/, "")
+      if command.strip.empty?
+        @prompt.say("\nShell command is required after !\n")
+        return true
+      end
+
+      run_busy_local_command_and_requeue(activity: "running") do
+        result = configured_workspace(root: interactive_workspace_root(agent)).run_shell_command(command)
+        @prompt.say("\n#{colored("Shell>", :green, :bold)} #{command}\n#{result}\n")
+      end
+      true
+    end
+
+    def shell_command_input?(input)
+      input.to_s.start_with?("!")
+    end
+
+    def configured_workspace(root: current_workspace_root)
+      Workspace.new(root: root, guardrails: workspace_guardrails_enabled?)
+    end
+
+    def workspace_guardrails_enabled?
+      ConfigFiles.workspace_guardrails_enabled?(safely_read_config.to_h)
+    end
+
+    def interactive_workspace_root(agent)
+      conversation = agent.conversation if agent.respond_to?(:conversation)
+      return conversation.workspace_root if conversation&.respond_to?(:workspace_root)
+
+      current_workspace_root
+    end
+
     def handle_local_slash_command(command, agent, session_store)
       name, argument = parse_slash_command(command)
       case name
@@ -395,9 +895,6 @@ module Kward
       when "stats"
         run_busy_local_command_and_requeue { print_stats(argument) }
         [true, nil]
-      when "crew"
-        @prompt.say("\nThe /crew command is not implemented yet.\n")
-        [true, nil]
       when "memory"
         activity = memory_summarize_command?(argument) ? "summarizing" : "loading"
         run_busy_local_command_and_requeue(activity: activity) { handle_memory_command(argument, agent) }
@@ -406,7 +903,7 @@ module Kward
         run_busy_local_command_and_requeue { @prompt.redraw if @prompt.respond_to?(:redraw) }
         [true, nil]
       when "settings"
-        configure_settings
+        configure_settings(agent.conversation)
         [true, nil]
       when "login"
         login_interactively
@@ -421,6 +918,9 @@ module Kward
       when "reasoning"
         configure_reasoning(agent.conversation)
         [true, nil]
+      when "reload"
+        run_busy_local_command_and_requeue { reload_plugins(agent.conversation) }
+        [true, nil]
       when "new"
         [true, run_busy_local_command_and_requeue { start_new_session(session_store) }]
       when "resume"
@@ -434,6 +934,8 @@ module Kward
         [true, nil]
       when "clone"
         [true, run_busy_local_command_and_requeue { clone_session(session_store, agent) }]
+      when "tree"
+        [true, run_busy_local_command_and_requeue { navigate_session_tree(session_store) }]
       when "copy"
         run_busy_local_command_and_requeue { copy_session_text(agent.conversation, argument) }
         [true, nil]
@@ -528,13 +1030,16 @@ module Kward
         record = manager.add_soft(unquote_argument(rest), scope: "workspace:#{agent.conversation.workspace_root}")
         @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} Added soft memory #{record["id"]}.\n")
       when "list"
-        @prompt.say("\n#{format_memory_list(manager.list)}\n")
+        @prompt.say("\n#{format_memory_list(manager.hierarchy(workspace_root: agent.conversation.workspace_root))}\n")
       when "forget"
         forgotten = manager.forget_memory(rest.to_s.strip)
         @prompt.say("\n#{forgotten ? "Forgot #{rest.to_s.strip}." : "No memory found for #{rest.to_s.strip}."}\n")
       when "promote"
-        record = manager.promote_soft_to_core(rest.to_s.strip)
-        @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} Promoted to core memory #{record["id"]}.\n")
+        record = manager.promote_memory(rest.to_s.strip)
+        @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} Promoted memory #{record["id"]}.\n")
+      when "relax"
+        record = manager.relax_core(rest.to_s.strip, workspace_root: agent.conversation.workspace_root)
+        @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} Relaxed memory #{record["id"]}.\n")
       when "inspect"
         @prompt.say("\n#{JSON.pretty_generate(manager.inspect_memory)}\n")
       when "why"
@@ -544,7 +1049,7 @@ module Kward
         records = summarize_memory(agent.conversation, manager: manager)
         @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} Learned #{records.length} soft #{records.length == 1 ? "memory" : "memories"}.\n")
       else
-        @prompt.say("\nUsage: /memory enable|disable|auto-summary enable|disable|core <text>|add <text>|list|forget <id>|promote <id>|inspect|why|summarize\n")
+        @prompt.say("\nUsage: /memory enable|disable|auto-summary enable|disable|core <text>|add <text>|list|forget <id>|promote <id>|relax <id>|inspect|why|summarize\n")
       end
     rescue StandardError => e
       @prompt.say("\nMemory command failed: #{e.message}\n")
@@ -563,13 +1068,18 @@ module Kward
     end
 
     def format_memory_list(memories)
-      lines = ["Core Memories:"]
-      Array(memories["core"]).each { |item| lines << "- #{item["id"]} [#{item["scope"]}] #{item["text"]}" }
-      lines << "- none" if Array(memories["core"]).empty?
-      lines << "Soft Memories:"
-      Array(memories["soft"]).each { |item| lines << "- #{item["id"]} [#{item["scope"]}] #{item["text"]}" }
-      lines << "- none" if Array(memories["soft"]).empty?
-      lines.join("\n")
+      sections = [
+        ["Global Core Memories:", Array(memories["global_core"])],
+        ["Workspace Core Memories:", Array(memories["workspace_core"])],
+        ["Workspace Soft Memories:", Array(memories["workspace_soft"])]
+      ]
+
+      sections.flat_map do |heading, records|
+        lines = [heading]
+        records.each { |item| lines << "- #{item["id"]} [#{item["scope"]}] #{item["text"]}" }
+        lines << "- none" if records.empty?
+        lines
+      end.join("\n")
     end
 
     def format_memory_why(explanation)
@@ -616,33 +1126,478 @@ module Kward
 
     def current_workspace_root
       return @active_session.cwd.to_s unless @active_session&.cwd.to_s.empty?
+      return @working_directory if @working_directory
 
       Dir.pwd
     end
 
-    def configure_settings
+    def configure_settings(conversation = nil)
       unless settings_overlay_available?
         @prompt.say("\nSettings overlay is unavailable in this prompt.\n")
         return
       end
 
-      settings = ConfigFiles.overlay_settings
-      alignment = choose_overlay_setting("Overlay alignment", overlay_alignment_choices(settings), ConfigFiles::OVERLAY_ALIGNMENTS)
-      return unless alignment
-
-      settings = ConfigFiles.update_overlay_settings("alignment" => alignment)
-      @prompt.update_overlay_settings(settings)
+      loop do
+        selected = @prompt.select("Settings category", settings_category_choices, title: "Settings")
+        category = selected_settings_category(selected)
+        break unless category
 
-      width = choose_overlay_setting("Overlay width", overlay_width_choices(settings), ConfigFiles::OVERLAY_WIDTHS)
-      return unless width
+        break if category == "done"
 
-      settings = ConfigFiles.update_overlay_settings("width" => width)
-      @prompt.update_overlay_settings(settings)
-      @prompt.say("\nSaved overlay settings.\n")
+        handle_settings_category(category, conversation)
+      end
     rescue StandardError => e
       @prompt.say("\nSettings error: #{e.message}\n")
     end
 
+    def settings_category_choices
+      [
+        "Model & Reasoning",
+        "Accounts",
+        "Memory",
+        "Interface",
+        "Tools & Search",
+        "Context & Compaction",
+        "Personalization",
+        "Logging",
+        "Advanced",
+        "Done"
+      ]
+    end
+
+    def selected_settings_category(selected)
+      text = selected.to_s.downcase
+      return nil if text.empty?
+      return "done" if text.start_with?("done")
+      return "model" if text.start_with?("model")
+      return "accounts" if text.start_with?("accounts")
+      return "memory" if text.start_with?("memory")
+      return "interface" if text.start_with?("interface")
+      return "tools" if text.start_with?("tools")
+      return "context" if text.start_with?("context")
+      return "personalization" if text.start_with?("personalization")
+      return "logging" if text.start_with?("logging")
+      return "advanced" if text.start_with?("advanced")
+
+      nil
+    end
+
+    def handle_settings_category(category, conversation)
+      case category
+      when "model"
+        configure_model_settings(conversation)
+      when "accounts"
+        configure_account_settings
+      when "memory"
+        configure_memory_settings(conversation)
+      when "interface"
+        configure_interface_settings
+      when "tools"
+        configure_tools_settings
+      when "context"
+        configure_context_settings
+      when "personalization"
+        configure_personalization_settings(conversation)
+      when "logging"
+        configure_logging_settings
+      when "advanced"
+        show_advanced_settings
+      end
+    end
+
+    def configure_model_settings(conversation)
+      selected = @prompt.select("Model & Reasoning", ["Provider", "Default model", "Reasoning effort", "Back"], title: "Settings")
+      case selected.to_s.downcase
+      when /\Aprovider/
+        configure_provider(conversation)
+      when /\Adefault model/
+        configure_model(conversation)
+      when /\Areasoning effort/
+        configure_reasoning(conversation)
+      end
+    end
+
+    def configure_provider(conversation)
+      selected = @prompt.select("Provider", provider_choices, title: "Settings")
+      provider = selected_provider(selected)
+      return unless provider
+
+      ConfigFiles.update_config("provider" => ModelInfo.config_provider_for_provider(provider))
+      reload_client_config
+      refresh_conversation_runtime(conversation)
+      @prompt.redraw if @prompt.respond_to?(:redraw)
+    end
+
+    def provider_choices
+      current = current_model_provider
+      ["Codex", "OpenRouter", "Copilot"].map do |provider|
+        label = provider.dup
+        label += " (current)" if provider == current
+        label
+      end
+    end
+
+    def selected_provider(selected)
+      text = selected.to_s.downcase
+      return "Codex" if text.start_with?("codex")
+      return "OpenRouter" if text.start_with?("openrouter")
+      return "Copilot" if text.start_with?("copilot")
+
+      nil
+    end
+
+    def configure_account_settings
+      selected = @prompt.select("Accounts", account_setting_choices, title: "Settings")
+      case selected.to_s.downcase
+      when /\Aopenai/
+        login(provider: "openai")
+        reload_client_config
+      when /\Agithub/
+        login(provider: "github")
+        reload_client_config
+      when /\Aopenrouter/
+        login(provider: "openrouter")
+        reload_client_config
+      when /\Astatus/
+        print_auth_status
+      end
+    end
+
+    def account_setting_choices
+      config = safely_read_config.to_h
+      [
+        "OpenAI login (#{File.exist?(OpenAIOAuth.default_auth_path) ? "configured" : "not configured"})",
+        "GitHub login (#{File.exist?(GithubOAuth.default_auth_path) ? "configured" : "not configured"})",
+        "OpenRouter API key (#{openrouter_key_status(config)})",
+        "Status",
+        "Back"
+      ]
+    end
+
+    def openrouter_key_status(config)
+      return "configured via environment" unless ENV["OPENROUTER_API_KEY"].to_s.empty?
+
+      config["openrouter_api_key"].to_s.empty? ? "not configured" : "configured"
+    end
+
+    def configure_memory_settings(conversation)
+      selected = @prompt.select("Memory", memory_setting_choices, title: "Settings")
+      case selected.to_s.downcase
+      when /\Aenable memory/, /\Adisable memory/
+        set_memory_enabled(!memory_enabled?)
+        conversation&.refresh_system_message!
+        @prompt.say("\nMemory #{memory_enabled? ? "enabled" : "disabled"}.\n")
+      when /\Aenable auto-summary/, /\Adisable auto-summary/
+        set_memory_auto_summary_enabled(!memory_auto_summary_enabled?)
+        @prompt.say("\nMemory auto-summary #{memory_auto_summary_enabled? ? "enabled" : "disabled"}.\n")
+      when /\Amanage/
+        @prompt.say("\nUse /memory enable|disable|auto-summary enable|disable|core <text>|add <text>|list|forget <id>|promote <id>|relax <id>|inspect|why|summarize.\n")
+      end
+    end
+
+    def memory_setting_choices
+      [
+        "#{memory_enabled? ? "Disable" : "Enable"} memory (currently #{on_off(memory_enabled?)})",
+        "#{memory_auto_summary_enabled? ? "Disable" : "Enable"} auto-summary (currently #{on_off(memory_auto_summary_enabled?)})",
+        "Manage memories with /memory",
+        "Back"
+      ]
+    end
+
+    def memory_enabled?
+      memory = safely_read_config.to_h["memory"]
+      memory.is_a?(Hash) && memory["enabled"] == true
+    end
+
+    def memory_auto_summary_enabled?
+      memory = safely_read_config.to_h["memory"]
+      memory.is_a?(Hash) && memory["auto_summary"] == true
+    end
+
+    def set_memory_enabled(enabled)
+      update_nested_config("memory", "enabled" => enabled)
+    end
+
+    def set_memory_auto_summary_enabled(enabled)
+      update_nested_config("memory", "auto_summary" => enabled)
+    end
+
+    def configure_interface_settings
+      selected = @prompt.select("Interface", interface_setting_choices, title: "Settings")
+      case selected.to_s.downcase
+      when /\Aoverlay alignment/
+        settings = ConfigFiles.overlay_settings
+        alignment = choose_overlay_setting("Overlay alignment", overlay_alignment_choices(settings), ConfigFiles::OVERLAY_ALIGNMENTS)
+        return unless alignment
+
+        @prompt.update_overlay_settings(ConfigFiles.update_overlay_settings("alignment" => alignment))
+      when /\Aoverlay width/
+        settings = ConfigFiles.overlay_settings
+        width = choose_overlay_setting("Overlay width", overlay_width_choices(settings), ConfigFiles::OVERLAY_WIDTHS)
+        return unless width
+
+        @prompt.update_overlay_settings(ConfigFiles.update_overlay_settings("width" => width))
+      when /\Ashow busy help/, /\Ahide busy help/
+        set_composer_busy_help(!composer_busy_help?)
+        @prompt.say("\nBusy help #{composer_busy_help? ? "enabled" : "disabled"}. Restart the TUI to apply this setting.\n")
+      when /\Ashow startup banner/, /\Ahide startup banner/
+        set_banner_enabled(!banner_enabled?)
+        @prompt.say("\nStartup banner #{banner_enabled? ? "enabled" : "disabled"}. Restart the TUI to apply this setting.\n")
+      when /\Aenable session auto-resume/, /\Adisable session auto-resume/
+        set_session_auto_resume_enabled(!session_auto_resume_enabled?)
+        @prompt.say("\nSession auto-resume #{session_auto_resume_enabled? ? "enabled" : "disabled"}.\n")
+      end
+    end
+
+    def interface_setting_choices
+      settings = ConfigFiles.overlay_settings
+      [
+        "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"
+      ]
+    end
+
+    def composer_busy_help?
+      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
+
+    def set_composer_busy_help(enabled)
+      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
+
+    def configure_tools_settings
+      selected = @prompt.select("Tools & Search", tools_setting_choices, title: "Settings")
+      case selected.to_s.downcase
+      when /\Aenable web search/, /\Adisable web search/
+        set_web_search_enabled(!web_search_enabled?)
+        @prompt.say("\nWeb search #{web_search_enabled? ? "enabled" : "disabled"}.\n")
+      when /\Aweb search provider/
+        configure_web_search_provider
+      when /\Aallow model-provider/, /\Adisallow model-provider/
+        set_web_search_allow_model_providers(!web_search_allow_model_providers?)
+        @prompt.say("\nModel-provider web search #{web_search_allow_model_providers? ? "enabled" : "disabled"}.\n")
+      when /\Aenable workspace guardrails/, /\Adisable workspace guardrails/
+        set_workspace_guardrails_enabled(!workspace_guardrails_enabled?)
+        @prompt.say("\nWorkspace guardrails #{workspace_guardrails_enabled? ? "enabled" : "disabled"}.\n")
+      end
+    end
+
+    def tools_setting_choices
+      [
+        "#{web_search_enabled? ? "Disable" : "Enable"} web search (currently #{on_off(web_search_enabled?)})",
+        "Web search provider (#{web_search_provider})",
+        "#{web_search_allow_model_providers? ? "Disallow" : "Allow"} model-provider web search (currently #{on_off(web_search_allow_model_providers?)})",
+        "#{workspace_guardrails_enabled? ? "Disable" : "Enable"} workspace guardrails (currently #{on_off(workspace_guardrails_enabled?)})",
+        "Back"
+      ]
+    end
+
+    def configure_web_search_provider
+      providers = %w[auto exa perplexity gemini legacy]
+      selected = @prompt.select("Web search provider", providers.map { |provider| provider == web_search_provider ? "#{provider} (current)" : provider }, title: "Settings")
+      provider = providers.find { |value| selected.to_s.downcase.start_with?(value) }
+      return unless provider
+
+      update_nested_config("web_search", "provider" => provider)
+    end
+
+    def web_search_config
+      config = safely_read_config.to_h
+      value = config["web_search"] || config["webSearch"] || config["web_research"] || config["webResearch"]
+      value.is_a?(Hash) ? value : {}
+    end
+
+    def web_search_enabled?
+      web_search_config["enabled"] != false
+    end
+
+    def web_search_provider
+      web_search_config["provider"].to_s.empty? ? "auto" : web_search_config["provider"].to_s
+    end
+
+    def web_search_allow_model_providers?
+      web_search_config["allow_model_providers"] == true
+    end
+
+    def set_web_search_enabled(enabled)
+      update_nested_config("web_search", "enabled" => enabled)
+    end
+
+    def set_web_search_allow_model_providers(enabled)
+      update_nested_config("web_search", "allow_model_providers" => enabled)
+    end
+
+    def set_workspace_guardrails_enabled(enabled)
+      update_nested_config("tools", "workspace_guardrails" => enabled)
+    end
+
+    def configure_context_settings
+      selected = @prompt.select("Context & Compaction", context_setting_choices, title: "Settings")
+      case selected.to_s.downcase
+      when /\Aenable auto-compaction/, /\Adisable auto-compaction/
+        set_compaction_enabled(!compaction_enabled?)
+        @prompt.say("\nAuto-compaction #{compaction_enabled? ? "enabled" : "disabled"}.\n")
+      else
+        @prompt.say("\n#{auto_compaction_status_line}\n") if selected.to_s.downcase.start_with?("status")
+      end
+    end
+
+    def context_setting_choices
+      [
+        "#{compaction_enabled? ? "Disable" : "Enable"} auto-compaction (currently #{on_off(compaction_enabled?)})",
+        "Status",
+        "Back"
+      ]
+    end
+
+    def compaction_enabled?
+      Kward::Compaction::Settings.from_config(safely_read_config.to_h).enabled
+    end
+
+    def set_compaction_enabled(enabled)
+      update_nested_config("compaction", "enabled" => enabled)
+    end
+
+    def configure_personalization_settings(conversation)
+      selected = @prompt.select("Personalization", personalization_setting_choices(conversation), title: "Settings")
+      case selected.to_s.downcase
+      when /\Adefault persona/
+        configure_default_persona(conversation)
+      when /\Aactive instructions/
+        show_active_instructions_summary(conversation)
+      end
+    end
+
+    def personalization_setting_choices(conversation)
+      [
+        "Default persona (#{default_persona_label})",
+        "Active instructions summary",
+        "Back"
+      ]
+    end
+
+    def default_persona_label
+      personas = safely_read_config.to_h["personas"]
+      value = personas.is_a?(Hash) ? personas["default"] : nil
+      value.to_s.empty? ? "none" : value.to_s
+    end
+
+    def configure_default_persona(conversation)
+      config = safely_read_config.to_h
+      personas = config["personas"].is_a?(Hash) ? config["personas"] : {}
+      entries = ConfigFiles.crew_character_labels(personas)
+      choices = entries.map { |key, label| key == personas["default"] ? "#{label} (#{key}, current)" : "#{label} (#{key})" }
+      if choices.empty?
+        @prompt.say("\nNo configured personas found. Edit #{ConfigFiles.config_path} to add personas.\n")
+        return
+      end
+
+      selected = @prompt.select("Default persona", choices, title: "Settings")
+      key = entries.keys.find { |candidate| selected.to_s.include?("(#{candidate}") }
+      return unless key
+
+      personas = personas.dup
+      personas["default"] = key
+      ConfigFiles.update_config("personas" => personas)
+      conversation&.refresh_system_message!
+      @prompt.redraw if @prompt.respond_to?(:redraw)
+    end
+
+    def show_active_instructions_summary(conversation)
+      label = ConfigFiles.active_persona_label(workspace_root: current_workspace_root, model: current_model_id, config: safely_read_config.to_h)
+      lines = ["Active persona: #{label || "none"}"]
+      lines << "Global AGENTS.md: #{ConfigFiles.agents_prompt ? "present" : "absent"}"
+      lines << "Workspace AGENTS.md: #{ConfigFiles.workspace_agents_prompt(current_workspace_root) ? "present" : "absent"}"
+      lines << "Messages: #{conversation.messages.length}" if conversation&.respond_to?(:messages)
+      @prompt.say("\n#{lines.join("\n")}\n")
+    end
+
+    def configure_logging_settings
+      selected = @prompt.select("Logging", logging_setting_choices, title: "Settings")
+      key = logging_key_for_choice(selected)
+      return unless key
+
+      set_logging_value(key, !logging_enabled?(key))
+      @prompt.say("\nLogging #{key.tr("_", " ")} #{logging_enabled?(key) ? "enabled" : "disabled"}.\n")
+    end
+
+    def logging_setting_choices
+      [
+        "#{logging_enabled?("enabled") ? "Disable" : "Enable"} local logging (currently #{on_off(logging_enabled?("enabled"))})",
+        "#{logging_enabled?("tokens") ? "Disable" : "Enable"} token logs (currently #{on_off(logging_enabled?("tokens"))})",
+        "#{logging_enabled?("performance") ? "Disable" : "Enable"} performance logs (currently #{on_off(logging_enabled?("performance"))})",
+        "#{logging_enabled?("tools") ? "Disable" : "Enable"} tool logs (currently #{on_off(logging_enabled?("tools"))})",
+        "#{logging_enabled?("errors") ? "Disable" : "Enable"} error logs (currently #{on_off(logging_enabled?("errors"))})",
+        "Back"
+      ]
+    end
+
+    def logging_key_for_choice(selected)
+      text = selected.to_s.downcase
+      return "enabled" if text.include?("local logging")
+      return "tokens" if text.include?("token logs")
+      return "performance" if text.include?("performance logs")
+      return "tools" if text.include?("tool logs")
+      return "errors" if text.include?("error logs")
+
+      nil
+    end
+
+    def logging_enabled?(key)
+      logging = safely_read_config.to_h["logging"]
+      logging.is_a?(Hash) && logging[key] == true
+    end
+
+    def set_logging_value(key, value)
+      update_nested_config("logging", key => value)
+    end
+
+    def show_advanced_settings
+      lines = [
+        "Config path: #{ConfigFiles.config_path}",
+        "Config directory: #{ConfigFiles.config_dir}",
+        "Cache directory: #{ConfigFiles.cache_dir}",
+        "Memory directory: #{ConfigFiles.memory_dir}",
+        "Plugin directory: #{ConfigFiles.plugin_dir}",
+        "Plugins: #{ConfigFiles.plugin_paths.length}",
+        "Skills: #{ConfigFiles.skills.length}",
+        "Prompt templates: #{ConfigFiles.prompt_templates(reserved_commands: BUILTIN_SLASH_COMMAND_NAMES).length}"
+      ]
+      @prompt.say("\n#{lines.join("\n")}\n")
+    end
+
+    def update_nested_config(section, values)
+      config = ConfigFiles.read_config
+      current = config[section].is_a?(Hash) ? config[section].dup : {}
+      config[section] = current.merge(values)
+      ConfigFiles.write_config(config)
+      config
+    end
+
+    def on_off(value)
+      value ? "on" : "off"
+    end
+
     def login_interactively
       unless login_picker_available?
         @prompt.say("\nLogin provider picker is unavailable in this prompt.\n")
@@ -862,7 +1817,7 @@ module Kward
       return nil if path.to_s.empty?
 
       previous_session = @active_session
-      @active_session, conversation = session_store.load(path, workspace: Workspace.new(root: session_store.cwd), model: current_model_id, reasoning_effort: current_reasoning_effort)
+      @active_session, conversation = session_store.load(path, workspace: configured_workspace(root: session_store.cwd), model: current_model_id, reasoning_effort: current_reasoning_effort)
       reset_session_diff(@active_session.path)
       track_session(@active_session)
       cleanup_replaced_session(previous_session)
@@ -879,6 +1834,92 @@ module Kward
       nil
     end
 
+
+    def navigate_session_tree(session_store)
+      return say_sessions_unavailable unless session_store
+      unless @active_session
+        @prompt.say("\nNo active persisted session.\n")
+        return nil
+      end
+
+      tree_items = session_tree_items(session_store)
+      if tree_items.empty?
+        @prompt.say("\nNo session tree entries found.\n")
+        return nil
+      end
+
+      labels_by_entry_id = tree_items.to_h { |item| [item[:entry]["id"].to_s, item[:label]] }
+      current_leaf_id = @active_session.leaf_id || session_store.current_leaf(@active_session.path)
+      initial_index = tree_items.index { |item| item[:entry]["id"].to_s == current_leaf_id.to_s } || tree_items.length - 1
+      choice = select_session_tree_entry(labels_by_entry_id.values, initial_index: initial_index)
+      return nil unless choice
+
+      entry_id = labels_by_entry_id.key(choice)
+      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)
+      @prompt.say("\nMoved session tree position to #{entry["id"]}.\n")
+      if selected_text && !selected_text.empty?
+        if @prompt.respond_to?(:prefill_input)
+          @prompt.prefill_input(selected_text)
+        else
+          @prompt.say("\nSelected text for editing:\n#{selected_text}\n")
+        end
+      end
+      agent = reload_active_session(session_store)
+      @prompt.redraw if @prompt.respond_to?(:redraw)
+      agent
+    rescue StandardError => e
+      @prompt.say("\nSession tree error: #{e.message}\n")
+      nil
+    end
+
+    def select_session_tree_entry(labels, initial_index: 0)
+      if @prompt.respond_to?(:select)
+        return @prompt.select("Tree>", labels, title: "Session Tree", initial_index: initial_index)
+      end
+
+      numbered_labels = labels.each_with_index.map { |label, index| "#{index + 1}. #{label}" }
+      @prompt.say("\nSession tree:\n#{numbered_labels.join("\n")}\n")
+      answer = @prompt.ask("Tree entry number>").to_s.strip
+      answer.match?(/\A\d+\z/) ? labels[answer.to_i - 1] : nil
+    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)
+        return full_message_text(message)
+      end
+
+      @active_session.branch(entry["id"])
+      nil
+    end
+
+    def reload_active_session(session_store)
+      @active_session, conversation = session_store.load(
+        @active_session.path,
+        workspace: configured_workspace(root: session_store.cwd),
+        model: current_model_id,
+        reasoning_effort: current_reasoning_effort
+      )
+      reset_session_diff(@active_session.path)
+      track_session(@active_session)
+      update_assistant_prompt(conversation)
+      restore_prompt_transcript do
+        render_conversation_transcript(conversation)
+      end
+      build_interactive_agent(conversation)
+    end
+
+    def session_tree_items(session_store)
+      roots = session_store.session_tree(@active_session.path)
+      current_leaf_id = @active_session.leaf_id || session_store.current_leaf(@active_session.path)
+      SessionTreeRenderer.new(roots: roots, current_leaf_id: current_leaf_id).items
+    end
+
     def rename_session(argument)
       unless @active_session
         @prompt.say("\nNo active persisted session.\n")
@@ -931,6 +1972,10 @@ module Kward
       nil
     end
 
+    def full_message_text(message)
+      CLITranscriptFormatter.full_text(message)
+    end
+
     def copy_target_content(conversation, target)
       case target
       when "last"
@@ -946,7 +1991,7 @@ module Kward
       message = conversation.messages.reverse.find { |item| message_role(item) == "assistant" }
       return "" unless message
 
-      message_content_text(message_content(message))
+      CLITranscriptFormatter.content_text(message_content(message))
     end
 
     def copy_target_label(target)
@@ -978,10 +2023,10 @@ module Kward
         case role
         when "user"
           print_user_transcript(
-            message_user_transcript_input(message),
-            display_input: message_user_display_text(message),
-            attachment_references: message_image_references(message),
-            image_parts: message_image_parts(message)
+            CLITranscriptFormatter.user_transcript_input(message),
+            display_input: CLITranscriptFormatter.user_display_text(message),
+            attachment_references: CLITranscriptFormatter.image_references(message),
+            image_parts: CLITranscriptFormatter.image_parts(message)
           )
         when "assistant"
           render_reasoning(message)
@@ -995,25 +2040,25 @@ module Kward
         when "compactionSummary"
           render_transcript_block("Compaction summary", message_summary(message))
         else
-          render_transcript_block(role.to_s.capitalize, message_content_text(message_content(message)))
+          render_transcript_block(role.to_s.capitalize, CLITranscriptFormatter.content_text(message_content(message)))
         end
       end
     end
 
     def render_reasoning(message)
-      reasoning = message_reasoning(message)
+      reasoning = CLITranscriptFormatter.reasoning(message)
       render_transcript_block("Reasoning", reasoning) unless reasoning.empty?
     end
 
     def render_assistant_message(message)
-      content = message_content_text(message_content(message))
+      content = CLITranscriptFormatter.content_text(message_content(message))
       return if content.empty?
 
       render_transcript_block("Assistant", content)
     end
 
     def render_tool_message(message, tool_calls_by_id)
-      tool_call = tool_calls_by_id[message_tool_call_id(message)] || synthetic_tool_call(message_name(message), message_tool_call_id(message))
+      tool_call = tool_calls_by_id[message_tool_call_id(message)] || CLITranscriptFormatter.synthetic_tool_call(message_name(message), message_tool_call_id(message))
       render_tool_result(tool_call, message_content(message).to_s)
     end
 
@@ -1106,113 +2151,6 @@ module Kward
       [["Reasoning", grouped["Reasoning"]], ["Assistant", grouped["Assistant"]]] + others
     end
 
-    def message_reasoning(message)
-      direct = message["reasoning_summary"] || message[:reasoning_summary]
-      return direct.to_s unless direct.to_s.empty?
-
-      content = message_content(message)
-      return "" unless content.is_a?(Array)
-
-      content.filter_map do |part|
-        type = part["type"] || part[:type]
-        next unless ["thinking", "reasoning"].include?(type)
-
-        part["thinking"] || part[:thinking] || part["text"] || part[:text]
-      end.join("\n")
-    end
-
-    def message_content_text(content)
-      case content
-      when Array
-        content.filter_map do |part|
-          type = part["type"] || part[:type]
-          if type == "text"
-            part["text"] || part[:text]
-          elsif type == "image"
-            path = part["path"] || part[:path]
-            media_type = part["media_type"] || part[:media_type] || "image"
-            "[#{media_type}#{path ? ": #{path}" : ""}]"
-          end
-        end.join("\n")
-      else
-        content.to_s
-      end
-    end
-
-    def message_display_text(message)
-      display_content = MessageAccess.display_content(message)
-      return display_content.to_s unless display_content.nil?
-
-      message_content_text(message_content(message))
-    end
-
-    def message_user_display_text(message)
-      display_content = MessageAccess.display_content(message)
-      return display_content.to_s unless display_content.nil?
-
-      content = message_content(message)
-      return content.to_s unless content.is_a?(Array)
-
-      text = content.filter_map do |part|
-        type = part["type"] || part[:type]
-        next unless type == "text"
-
-        part["text"] || part[:text]
-      end.join("\n")
-      Kward::ImageAttachments.display_text_without_references(text, Kward::ImageAttachments.references_from_text(text).select { |reference| reference[:status] == :attached })
-    end
-
-    def message_user_transcript_input(message)
-      content = message_content(message)
-      return content.to_s unless content.is_a?(Array)
-
-      message_user_display_text(message)
-    end
-
-    def message_image_parts(message)
-      content = message_content(message)
-      return [] unless content.is_a?(Array)
-
-      content.select do |part|
-        type = part["type"] || part[:type]
-        type == "image"
-      end
-    end
-
-    def message_image_references(message)
-      message_image_parts(message).map { |part| image_part_reference(part) }
-    end
-
-    def image_part_reference(part)
-      data = part[:data] || part["data"]
-      path = part[:path] || part["path"]
-      media_type = part[:media_type] || part["media_type"] || part[:mimeType] || part["mimeType"] || "image"
-      {
-        status: :attached,
-        type: "image",
-        label: path.to_s.empty? ? "pasted image" : File.basename(path),
-        media_type: media_type,
-        size_bytes: decoded_image_size(data),
-        path: path
-      }
-    end
-
-    def decoded_image_size(data)
-      return nil if data.to_s.empty?
-
-      Base64.decode64(data.to_s.gsub(/\s+/, "")).bytesize
-    rescue ArgumentError
-      nil
-    end
-
-    def synthetic_tool_call(name, id)
-      {
-        "id" => id || "restored_tool",
-        "type" => "function",
-        "function" => { "name" => name || "tool", "arguments" => "{}" }
-      }
-    end
-
     def message_role(message)
       MessageAccess.role(message)
     end
@@ -1267,10 +2205,7 @@ module Kward
     end
 
     def select_session_path(session_store)
-      recent_limit = 20
-      sessions = session_store.recent_tree(limit: recent_limit + 1)
-                              .reject { |session| active_empty_unnamed_session_info?(session) }
-                              .first(recent_limit)
+      sessions = session_store.recent(limit: nil)
       if sessions.empty?
         @prompt.say("\nNo saved sessions found.\n")
         return nil
@@ -1295,13 +2230,6 @@ module Kward
       end
     end
 
-    def active_empty_unnamed_session_info?(session)
-      return false unless @active_session
-      return false unless File.expand_path(session.path) == File.expand_path(@active_session.path)
-
-      session.name.to_s.strip.empty? && session.message_count.to_i.zero?
-    end
-
     def session_label(session)
       title = session.name.to_s.strip
       title = session.first_message.to_s.strip if title.empty?
@@ -1341,6 +2269,7 @@ 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,
@@ -1349,8 +2278,8 @@ module Kward
         busy_help: ConfigFiles.composer_busy_help?,
         attachment_badges: method(:composer_attachment_badges),
         attachment_parser: method(:composer_attachment_parser),
-        banner_pixels: Kward::PromptInterface::BANNER_LOGO_PIXELS,
-        banner_message: Kward::PromptInterface::BANNER_MESSAGE
+        banner_pixels: banner_enabled ? Kward::PromptInterface::BANNER_LOGO_PIXELS : nil,
+        banner_message: banner_enabled ? Kward::PromptInterface::BANNER_MESSAGE : nil
       )
       @prompt.start
     end
@@ -1393,6 +2322,13 @@ module Kward
       plugin_registry.command_for(command)
     end
 
+    def reload_plugins(conversation)
+      @plugin_registry = PluginRegistry.load(reserved_commands: reserved_slash_command_names)
+      conversation.plugin_registry = @plugin_registry if conversation.respond_to?(:plugin_registry=)
+      conversation.refresh_system_message! if conversation.respond_to?(:refresh_system_message!)
+      @prompt.say("\nPlugins reloaded.\n")
+    end
+
     def reserved_slash_command_names
       BUILTIN_SLASH_COMMAND_NAMES + prompt_templates.map(&:command)
     end
@@ -1540,6 +2476,18 @@ module Kward
       "/#{entry[:name]}#{hint}#{description}"
     end
 
+    def auto_name_active_session(input)
+      return unless @active_session
+      return unless @active_session.name.to_s.strip.empty?
+
+      name = default_session_name(input)
+      @active_session.rename(name) unless name.empty?
+    end
+
+    def default_session_name(input)
+      input.to_s.gsub(/\s+/, " ").strip.slice(0, 120).to_s
+    end
+
     def run_interactive_turn(agent, input, display_input: nil)
       prepare_memory_context(agent.conversation, input) if agent.respond_to?(:conversation)
       print_user_transcript(input, display_input: display_input) if prompt_interface?
@@ -1649,7 +2597,7 @@ module Kward
       when Events::ToolResult
         stream_state[:streamed] = true
         finish_interactive_markdown_deltas(markdown_chunks, stream_state)
-        update_session_diff(event.content)
+        update_session_diff(event.content, tool_call: event.tool_call)
         print_tool_result(event.tool_call, event.content, line_limit: INTERACTIVE_TOOL_OUTPUT_LINE_LIMIT)
       end
     end
@@ -1891,9 +2839,13 @@ module Kward
     def print_retry(event)
       message = retry_message(event)
       if prompt_interface?
-        @prompt.start_stream_block("Retry")
-        @prompt.write_delta("#{message}\n")
-        @prompt.finish_stream_block
+        if @prompt.respond_to?(:write_stream_block)
+          @prompt.write_stream_block("Retry", "#{message}\n", finish: true)
+        else
+          @prompt.start_stream_block("Retry")
+          @prompt.write_delta("#{message}\n")
+          @prompt.finish_stream_block
+        end
       else
         start_stream_block("Retry")
         puts message
@@ -1908,9 +2860,13 @@ module Kward
 
     def print_tool_call(tool_call)
       if prompt_interface?
-        @prompt.start_stream_block("Tool")
-        @prompt.write_delta("#{tool_command(tool_call)}\n")
-        @prompt.finish_stream_block
+        if @prompt.respond_to?(:write_stream_block)
+          @prompt.write_stream_block("Tool", "#{tool_command(tool_call)}\n", finish: true)
+        else
+          @prompt.start_stream_block("Tool")
+          @prompt.write_delta("#{tool_command(tool_call)}\n")
+          @prompt.finish_stream_block
+        end
       else
         start_stream_block("Tool")
         puts tool_command(tool_call)
@@ -1923,10 +2879,14 @@ module Kward
       summary = tool_result_summary(tool_call, content)
       summary = limit_tool_output_lines(summary, line_limit) if line_limit
       if prompt_interface?
-        @prompt.start_stream_block("Tool output")
-        @prompt.write_delta(summary)
-        @prompt.write_delta("\n") unless summary.end_with?("\n")
-        @prompt.finish_stream_block
+        summary = summary.end_with?("\n") ? summary : "#{summary}\n"
+        if @prompt.respond_to?(:write_stream_block)
+          @prompt.write_stream_block("Tool output", summary, finish: true)
+        else
+          @prompt.start_stream_block("Tool output")
+          @prompt.write_delta(summary)
+          @prompt.finish_stream_block
+        end
       else
         start_stream_block("Tool output")
         print summary