kward 0.66.0 → 0.67.1

data/lib/kward/rpc/session_manager.rb

@@ -17,12 +17,14 @@ require_relative "../model/model_info"
 require_relative "../plugin_registry"
 require_relative "../prompts/commands"
 require_relative "../session_store"
+require_relative "../session_trash"
 require_relative "../steering"
 require_relative "../tools/tool_call"
 require_relative "../tools/registry"
 require_relative "../transcript_export"
 require_relative "../workspace"
 require_relative "prompt_bridge"
+require_relative "runtime_payloads"
 require_relative "tool_event_normalizer"
 require_relative "transcript_normalizer"
 
@@ -33,24 +35,31 @@ module Kward
       RPC_ATTACHMENT_MAX_BYTES = 10 * 1024 * 1024
       RPC_IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"].freeze
       STREAMING_BEHAVIORS = ["newTurn", "followUp", "steer"].freeze
+      FOOTER_REFRESH_INTERVAL = 1.0
       WORKER_STOP = Object.new.freeze
 
-      RpcSession = Struct.new(:id, :workspace_root, :store, :session, :conversation, :agent, :tool_registry, :prompt, :plugin_output, :queue, :worker, :running_turn_id, keyword_init: true)
-      Turn = Struct.new(:id, :session_id, :input, :status, :cancel_requested, :cancellation, :created_at, :started_at, :finished_at, :events, :next_sequence, :error, :streaming_behavior, :plugin_command_name, :plugin_arguments, :steering, keyword_init: true)
+      RpcSession = Struct.new(:id, :workspace_root, :store, :session, :conversation, :agent, :tool_registry, :prompt, :plugin_output, :queue, :worker, :running_turn_id, :footer_worker, :last_footer_text, keyword_init: true)
+      Turn = Struct.new(:id, :session_id, :input, :display_input, :status, :cancel_requested, :cancellation, :created_at, :started_at, :finished_at, :events, :next_sequence, :error, :streaming_behavior, :plugin_command_name, :plugin_arguments, :steering, keyword_init: true)
 
-      def initialize(server:, client: Client.new, config_dir: ConfigFiles.config_dir, context_usage: ContextUsage.new)
+      def initialize(server:, client: Client.new, config_dir: ConfigFiles.config_dir, context_usage: ContextUsage.new, session_trash: SessionTrash.new)
         @server = server
         @client = client
         @config_dir = config_dir
         @context_usage = context_usage
+        @session_trash = session_trash
         @sessions = {}
         @turns = {}
         @mutex = Mutex.new
       end
 
-      def create_session(workspace_root: Dir.pwd, name: nil)
+      def create_session(workspace_root: Dir.pwd, name: nil, resume_last: false)
         workspace_root = validate_workspace_root(workspace_root)
         store = SessionStore.new(config_dir: @config_dir, cwd: workspace_root)
+        if resume_last && session_auto_resume_enabled? && name.to_s.strip.empty?
+          path = store.remembered_last_session_path
+          return resume_session(path: path, workspace_root: workspace_root, include_transcript: true) if path
+        end
+
         conversation = new_conversation(workspace_root: workspace_root)
         session = store.create(model: conversation.model, reasoning_effort: conversation.reasoning_effort)
         session.rename(name) unless name.to_s.strip.empty?
@@ -58,10 +67,11 @@ module Kward
         rpc_session = build_rpc_session(store, session, conversation, workspace_root)
         remember_session(rpc_session)
         cleanup_other_unused_sessions(rpc_session)
+        emit_footer_update(rpc_session)
         session_payload(rpc_session)
       end
 
-      def resume_session(path:, workspace_root: nil)
+      def resume_session(path:, workspace_root: nil, include_transcript: false)
         root = validate_workspace_root(workspace_root || Dir.pwd)
         store = SessionStore.new(config_dir: @config_dir, cwd: root)
         location = store.session_location(path)
@@ -69,23 +79,26 @@ module Kward
         store = SessionStore.new(config_dir: @config_dir, cwd: root)
         session, conversation = store.load(
           location[:path],
-          workspace: Workspace.new(root: root),
+          workspace: configured_workspace(root),
           model: current_model_id,
           reasoning_effort: current_reasoning_effort
         )
         rpc_session = build_rpc_session(store, session, conversation, root)
         remember_session(rpc_session)
         cleanup_other_unused_sessions(rpc_session)
-        session_payload(rpc_session)
+        emit_footer_update(rpc_session)
+        payload = session_payload(rpc_session)
+        payload[:messages] = TranscriptNormalizer.new(rpc_session.conversation.messages).normalize if include_transcript
+        payload[:resumed] = true
+        payload
       end
 
-      def list_sessions(workspace_root: Dir.pwd, limit: 20)
+      def list_sessions(workspace_root: Dir.pwd, limit: nil, current_session_path: nil)
         root = validate_workspace_root(workspace_root)
         store = SessionStore.new(config_dir: @config_dir, cwd: root)
-        limit = limit.to_i <= 0 ? 20 : limit.to_i
-        store.recent_tree(limit: limit + active_session_count(root))
-             .reject { |info| active_empty_unnamed_session_info?(info, root) }
-             .first(limit)
+        requested_limit = limit.to_i if limit
+        requested_limit = nil unless requested_limit&.positive?
+        store.recent(limit: requested_limit, keep_empty_path: current_session_path)
              .map { |info| session_info_payload(info, workspace_root: root) }
       end
 
@@ -101,6 +114,7 @@ module Kward
         rpc_session = build_rpc_session(source.store, session, conversation, source.workspace_root)
         remember_session(rpc_session)
         cleanup_other_unused_sessions(rpc_session)
+        emit_footer_update(rpc_session)
         session_payload(rpc_session)
       end
 
@@ -124,39 +138,85 @@ module Kward
       def fork_messages(session_id:)
         rpc_session = fetch_session(session_id)
         {
-          messages: entry_messages(rpc_session.conversation).each_with_index.filter_map do |message, index|
-            next unless message_role(message) == "user"
+          messages: tree_entries(rpc_session).filter_map do |record|
+            message = record["message"]
+            next unless message.is_a?(Hash) && message_role(message) == "user"
 
-            { entryId: entry_id(index), text: display_message_text(message) }
+            { entryId: record["id"], text: display_message_text(message) }
           end
         }
       end
 
       def fork_session(session_id:, entry_id:)
         source = fetch_session(session_id)
-        index = entry_index(entry_id)
-        messages = entry_messages(source.conversation)
-        selected = messages[index] || raise(ArgumentError, "Unknown fork entryId: #{entry_id}")
-        raise ArgumentError, "Entry is not forkable: #{entry_id}" unless message_role(selected) == "user"
+        entries = tree_entries(source)
+        resolved_entry_id = resolve_tree_entry_id(entries, entry_id)
+        selected_index = entries.index { |record| record["id"].to_s == resolved_entry_id.to_s }
+        selected = selected_index && entries[selected_index]
+        raise ArgumentError, "Unknown fork entryId: #{entry_id}" unless selected
+
+        message = selected["message"]
+        raise ArgumentError, "Entry is not forkable: #{entry_id}" unless message.is_a?(Hash) && message_role(message) == "user"
 
         session, conversation = source.store.create_independent_from_messages(
-          messages[0...index],
+          entries[0...selected_index].filter_map { |record| record["message"] },
           model: source.conversation.model,
           reasoning_effort: source.conversation.reasoning_effort,
           parent_session: source.session
         )
 
-        # ensure forked sessions retain the original persona context
         rpc_session = build_rpc_session(source.store, session, conversation, source.workspace_root)
         remember_session(rpc_session)
         cleanup_other_unused_sessions(rpc_session)
         {
           session: session_payload(rpc_session),
-          text: full_message_text(selected),
+          text: full_message_text(message),
           cancelled: false
         }
       end
 
+      def session_tree(session_id:)
+        rpc_session = fetch_session(session_id)
+        { items: flatten_session_tree(rpc_session) }
+      end
+
+      def set_tree_label(session_id:, entry_id:, label: nil)
+        rpc_session = fetch_session(session_id)
+        rpc_session.session.append_label_change(entry_id, label)
+        { ok: true }
+      end
+
+      def navigate_tree(session_id:, entry_id:, summarize: false, custom_instructions: nil)
+        rpc_session = fetch_session(session_id)
+        entries = tree_entries(rpc_session)
+        resolved_entry_id = resolve_tree_entry_id(entries, entry_id)
+        entry = rpc_session.store.session_entry(rpc_session.session.path, resolved_entry_id)
+        raise ArgumentError, "Unknown tree entryId: #{entry_id}" unless entry
+
+        raise ArgumentError, "Tree entry is not selectable: #{entry_id}" unless selectable_tree_entry?(entry)
+
+        message = entry["message"]
+        user_entry = user_tree_entry?(entry)
+        target_leaf = user_entry ? entry["parentId"] : entry["id"]
+        editor_text = user_entry ? full_message_text(message) : nil
+        previous_leaf = rpc_session.session.leaf_id
+
+        if summarize
+          summary = summarize_branch(rpc_session, from_id: previous_leaf, to_id: target_leaf, custom_instructions: custom_instructions)
+          target_leaf = rpc_session.session.append_branch_summary(target_leaf, from_id: previous_leaf, summary: summary, details: {})
+        else
+          target_leaf ? rpc_session.session.branch(target_leaf) : rpc_session.session.reset_leaf
+        end
+
+        reload_rpc_session(rpc_session)
+        {
+          session: session_payload(rpc_session),
+          editorText: editor_text,
+          cancelled: false,
+          aborted: false
+        }.compact
+      end
+
       def export_session(session_id:, path: nil, format: nil)
         rpc_session = fetch_session(session_id)
         format = export_format(format)
@@ -169,9 +229,9 @@ module Kward
       def delete_session(session_id:)
         rpc_session = fetch_session(session_id)
         path = rpc_session.session.path
-        close_session(session_id: session_id)
-        File.delete(path) if File.exist?(path)
-        { deleted: true, path: path }
+        close_rpc_session(rpc_session, delete_unused: false)
+        deleted = @session_trash.delete(path)
+        { deleted: deleted, path: path }
       end
 
       def close_session(session_id:)
@@ -199,6 +259,7 @@ module Kward
         rpc_session = fetch_session(session_id)
         normalized_attachments = normalize_attachments(attachments)
         plugin_command, plugin_arguments = plugin_command_turn(input, normalized_attachments)
+        display_input = input.to_s if input.is_a?(String)
         content = plugin_command ? input.to_s : user_turn_content(expand_prompt_input(input), normalized_attachments)
         streaming_behavior = validate_streaming_behavior(default_streaming_behavior(rpc_session, streaming_behavior), rpc_session: rpc_session)
         if streaming_behavior == "steer"
@@ -211,6 +272,7 @@ module Kward
           id: SecureRandom.uuid,
           session_id: rpc_session.id,
           input: content,
+          display_input: display_input,
           status: "queued",
           cancel_requested: false,
           cancellation: Cancellation.new,
@@ -260,7 +322,6 @@ module Kward
 
       def run_command(session_id:, command:, arguments: "")
         name = command.to_s.delete_prefix("/")
-        return { ok: false, error: "unsupported", reason: "notImplemented" } if name == "crew"
         return { ok: false, error: "unsupported", reason: "clientClipboardOwnedByUi" } if name == "copy"
 
         run_plugin_command(session_id: session_id, command: name, arguments: arguments)
@@ -295,8 +356,8 @@ module Kward
         { autoSummary: false }
       end
 
-      def memory_list(include_inactive: false)
-        memory_manager.list(include_inactive: include_inactive)
+      def memory_list(include_inactive: false, workspace_root: Dir.pwd)
+        memory_manager.hierarchy(include_inactive: include_inactive, workspace_root: workspace_root)
       end
 
       def memory_add(text:, scope: nil, tags: [])
@@ -312,7 +373,11 @@ module Kward
       end
 
       def memory_promote(id:)
-        { memory: memory_manager.promote_soft_to_core(id) }
+        { memory: memory_manager.promote_memory(id) }
+      end
+
+      def memory_relax(id:, workspace_root: Dir.pwd)
+        { memory: memory_manager.relax_core(id, workspace_root: workspace_root) }
       end
 
       def memory_inspect
@@ -387,35 +452,18 @@ module Kward
           compaction_settings: compaction_settings
         )
         session = session_payload(rpc_session)
-        pending_count = pending_turn_count(rpc_session.id)
-        {
+        RuntimePayloads.state(
+          session: session,
           model: model,
-          thinkingLevel: model[:reasoningEffort],
-          isStreaming: streaming?(rpc_session),
-          isCompacting: false,
-          steeringMode: supports_in_flight_steer? ? "in-flight" : "one-at-a-time",
-          followUpMode: "one-at-a-time",
-          sessionFile: session[:path],
-          sessionId: session[:persistentId],
-          rpcSessionId: session[:id],
-          persistentSessionId: session[:persistentId],
-          sessionName: session[:name],
-          autoCompactionEnabled: compaction_settings.enabled,
-          autoCompactionReserveTokens: auto_compaction_reserve_tokens,
-          autoRetryEnabled: false,
-          defaultProvider: model[:provider],
-          defaultModel: default_model_label(model),
-          defaultThinkingLevel: model[:reasoningEffort],
-          hideThinkingBlock: false,
-          quietStartup: false,
-          transport: "kward-rpc",
-          imageAutoResize: false,
-          blockImages: false,
-          enabledModels: [],
-          enableSkillCommands: true,
-          messageCount: message_count(rpc_session.conversation),
-          pendingMessageCount: pending_count
-        }.compact
+          streaming: streaming?(rpc_session),
+          steering_supported: supports_in_flight_steer?,
+          auto_compaction_reserve_tokens: auto_compaction_reserve_tokens,
+          active_persona_label: active_persona_label(rpc_session),
+          message_count: message_count(rpc_session.conversation),
+          pending_count: pending_turn_count(rpc_session.id),
+          compaction_enabled: compaction_settings.enabled,
+          workspace_guardrails_enabled: workspace_guardrails_enabled?
+        )
       end
 
       def runtime_stats(session_id:)
@@ -428,22 +476,14 @@ module Kward
           context_window: model[:contextWindow],
           compaction_settings: compaction_settings
         )
-        {
-          sessionFile: session[:path],
-          sessionId: session[:persistentId],
-          rpcSessionId: session[:id],
-          persistentSessionId: session[:persistentId],
-          sessionName: session[:name],
-          userMessages: counts[:userMessages],
-          assistantMessages: counts[:assistantMessages],
-          toolCalls: counts[:toolCalls],
-          toolResults: counts[:toolResults],
-          totalMessages: counts[:totalMessages],
-          usingSubscription: model[:provider] == "Codex",
-          autoCompactionEnabled: compaction_settings.enabled,
-          autoCompactionReserveTokens: auto_compaction_reserve_tokens,
-          contextUsage: context_usage(rpc_session, model)
-        }.compact
+        RuntimePayloads.stats(
+          session: session,
+          counts: counts,
+          model: model,
+          auto_compaction_reserve_tokens: auto_compaction_reserve_tokens,
+          context_usage: context_usage(rpc_session, model),
+          compaction_enabled: compaction_settings.enabled
+        )
       end
 
       def refresh_client_config
@@ -452,19 +492,25 @@ module Kward
         refresh_session_tool_registries
       end
 
+      def reload_plugins
+        registry = PluginRegistry.load(reserved_commands: reserved_plugin_command_names)
+        sessions = @mutex.synchronize do
+          @plugin_registry = registry
+          @sessions.values
+        end
+        sessions.each do |rpc_session|
+          rpc_session.conversation.plugin_registry = registry if rpc_session.conversation.respond_to?(:plugin_registry=)
+          rpc_session.conversation.refresh_system_message! if rpc_session.conversation.respond_to?(:refresh_system_message!)
+          emit_footer_update(rpc_session)
+        end
+      end
+
       def session_payload(rpc_session)
-        {
-          id: rpc_session.id,
-          persistentId: rpc_session.session.id,
-          path: rpc_session.session.path,
-          workspaceRoot: rpc_session.workspace_root,
-          cwd: rpc_session.session.cwd.to_s.empty? ? rpc_session.workspace_root : rpc_session.session.cwd,
-          name: rpc_session.session.name,
-          createdAt: rpc_session.session.created_at&.utc&.iso8601(3),
-          modifiedAt: session_modified_at(rpc_session.session)&.utc&.iso8601(3),
-          parentId: rpc_session.session.parent_id,
-          parentPath: rpc_session.session.parent_path
-        }
+        RuntimePayloads.session(
+          rpc_session,
+          modified_at: session_modified_at(rpc_session.session),
+          active_persona_label: active_persona_label(rpc_session)
+        )
       end
 
       def session_modified_at(session)
@@ -515,8 +561,7 @@ module Kward
       end
 
       def compaction_settings
-        path = File.join(@config_dir, "config.json")
-        Kward::Compaction::Settings.from_config(ConfigFiles.read_config(path))
+        Kward::Compaction::Settings.from_config(ConfigFiles.read_config(config_path))
       rescue StandardError
         Kward::Compaction::Settings.new
       end
@@ -548,10 +593,11 @@ module Kward
         )
       end
 
-      def default_model_label(model)
-        return nil if model[:provider].to_s.empty? || model[:id].to_s.empty?
-
-        "#{model[:provider]}/#{model[:id]}"
+      def active_persona_label(rpc_session)
+        ConfigFiles.active_persona_label(
+          workspace_root: rpc_session.workspace_root,
+          model: rpc_session.conversation.model
+        ) || "Assistant"
       end
 
       def streaming?(rpc_session)
@@ -575,17 +621,6 @@ module Kward
         @mutex.synchronize { @sessions.values.count { |rpc_session| rpc_session.workspace_root == workspace_root } }
       end
 
-      def active_empty_unnamed_session_info?(info, workspace_root)
-        rpc_sessions = @mutex.synchronize { @sessions.values.dup }
-        rpc_sessions.any? do |rpc_session|
-          rpc_session.workspace_root == workspace_root &&
-            File.expand_path(rpc_session.session.path) == File.expand_path(info.path) &&
-            session_idle?(rpc_session) &&
-            info.name.to_s.strip.empty? &&
-            info.message_count.to_i.zero?
-        end
-      end
-
       def message_count(conversation)
         conversation.messages.count { |message| message_role(message) != "system" }
       end
@@ -634,23 +669,293 @@ module Kward
         MessageAccess.content(message)
       end
 
-      def entry_messages(conversation)
-        conversation.messages.reject { |message| message_role(message) == "system" }
+      def tree_entries(rpc_session)
+        rpc_session.store.session_entries(rpc_session.session.path)
+      end
+
+      def resolve_tree_entry_id(entries, entry_id)
+        id = entry_id.to_s
+        return id if entries.any? { |record| record["id"].to_s == id }
+
+        match = id.match(/\Amessage:(\d+)\z/)
+        return entries[match[1].to_i]&.dig("id") if match
+
+        id
+      end
+
+      def reload_rpc_session(rpc_session)
+        session, conversation = rpc_session.store.load(
+          rpc_session.session.path,
+          workspace: configured_workspace(rpc_session.workspace_root),
+          model: current_model_id,
+          reasoning_effort: current_reasoning_effort
+        )
+        conversation.plugin_registry ||= plugin_registry if conversation.respond_to?(:plugin_registry)
+        rpc_session.session = session
+        rpc_session.conversation = conversation
+        rebuild_session_tools(rpc_session)
+        emit_footer_update(rpc_session)
+      end
+
+      def flatten_session_tree(rpc_session)
+        roots = rpc_session.store.session_tree(rpc_session.session.path)
+        current_leaf = rpc_session.session.leaf_id || rpc_session.store.current_leaf(rpc_session.session.path)
+        active_path = tree_active_path(roots, current_leaf)
+        tool_calls_by_id = tree_tool_calls(roots)
+        visible_roots = roots.flat_map { |root| visible_tree_nodes(root, current_leaf) }
+        multiple_roots = visible_roots.length > 1
+        result = []
+
+        walk = lambda do |node, indent, just_branched, show_connector, is_last, gutters, virtual_root_child|
+          entry = node[:source]["entry"] || {}
+          entry_id = entry["id"].to_s
+          formatted = tree_entry_display(entry, tool_calls_by_id)
+          display_indent = multiple_roots ? [indent - 1, 0].max : indent
+          result << {
+            entryId: entry_id,
+            parentId: entry["parentId"],
+            role: formatted[:role],
+            text: formatted[:text],
+            current: !current_leaf.to_s.empty? && entry_id == current_leaf.to_s,
+            depth: display_indent,
+            isLast: is_last,
+            ancestorContinues: gutters.map { |gutter| gutter[:show] },
+            activePath: active_path.include?(entry_id),
+            selectable: selectable_tree_entry?(entry),
+            label: node[:source]["label"] || entry["resolvedLabel"],
+            labelTimestamp: node[:source]["labelTimestamp"],
+            prefix: tree_prefix(display_indent, gutters, show_connector && !virtual_root_child, is_last, !node[:children].empty?)
+          }.compact
+
+          children = node[:children].sort_by { |child| tree_contains_active_path?(child, active_path) ? 0 : 1 }
+          multiple_children = children.length > 1
+          child_indent = if multiple_children
+                           indent + 1
+                         elsif just_branched && indent.positive?
+                           indent + 1
+                         else
+                           indent
+                         end
+          connector_position = [display_indent - 1, 0].max
+          child_gutters = show_connector && !virtual_root_child ? gutters + [{ position: connector_position, show: !is_last }] : gutters
+          children.each_with_index do |child, index|
+            walk.call(child, child_indent, multiple_children, multiple_children, index == children.length - 1, child_gutters, false)
+          end
+        end
+
+        visible_roots.sort_by { |root| tree_contains_active_path?(root, active_path) ? 0 : 1 }.each_with_index do |root, index|
+          walk.call(root, multiple_roots ? 1 : 0, multiple_roots, multiple_roots, index == visible_roots.length - 1, [], multiple_roots)
+        end
+        result
+      end
+
+      def user_tree_entry?(entry)
+        message = entry["message"]
+        message.is_a?(Hash) && message_role(message) == "user"
+      end
+
+      def selectable_tree_entry?(entry)
+        !entry["id"].to_s.empty? && ["message", "compaction", "branch_summary"].include?(entry["type"])
+      end
+
+      def nearest_visible_parent_by_id(user_entries, entries)
+        user_ids = user_entries.map { |entry| entry["id"].to_s }.to_h { |id| [id, true] }
+        by_id = entries.to_h { |entry| [entry["id"].to_s, entry] }
+        user_entries.each_with_object({}) do |entry, parents|
+          parent_id = entry["parentId"]
+          while parent_id && by_id[parent_id.to_s] && !user_ids[parent_id.to_s]
+            parent_id = by_id[parent_id.to_s]["parentId"]
+          end
+          parents[entry["id"].to_s] = user_ids[parent_id.to_s] ? parent_id.to_s : nil
+        end
+      end
+
+      def active_path_ids(entries, leaf_id)
+        by_id = entries.to_h { |entry| [entry["id"].to_s, entry] }
+        ids = []
+        current = by_id[leaf_id.to_s]
+        while current
+          ids << current["id"].to_s
+          current = by_id[current["parentId"].to_s]
+        end
+        ids
+      end
+
+      def tree_active_path(roots, leaf_id)
+        by_id = tree_entries_by_id(roots)
+        ids = []
+        current = by_id[leaf_id.to_s]
+        while current
+          ids << current["id"].to_s
+          current = by_id[current["parentId"].to_s]
+        end
+        ids
+      end
+
+      def tree_entries_by_id(roots)
+        roots.each_with_object({}) do |root, map|
+          stack = [root]
+          until stack.empty?
+            node = stack.pop
+            entry = node["entry"] || {}
+            map[entry["id"].to_s] = entry unless entry["id"].to_s.empty?
+            stack.concat(Array(node["children"]))
+          end
+        end
+      end
+
+      def visible_tree_nodes(node, current_leaf)
+        children = Array(node["children"]).flat_map { |child| visible_tree_nodes(child, current_leaf) }
+        return children if hidden_tree_entry?(node["entry"] || {}, current_leaf)
+
+        [{ source: node, children: children }]
+      end
+
+      def hidden_tree_entry?(entry, current_leaf)
+        return false if current_leaf && entry["id"].to_s == current_leaf.to_s
+        return false unless entry["type"] == "message"
+
+        message = entry["message"]
+        return false unless message.is_a?(Hash) && message_role(message) == "assistant"
+
+        content = message_content(message)
+        content_tool_calls = content.is_a?(Array) && content.any? { |part| ToolCall.value(part, :type) == "toolCall" }
+        (content_tool_calls && !tree_text_content?(content)) || (!tool_calls(message).empty? && full_message_text(message).empty?)
+      end
+
+      def tree_text_content?(content)
+        Array(content).any? { |part| ToolCall.value(part, :type) == "text" && ToolCall.value(part, :text).to_s.strip != "" }
       end
 
-      def entry_id(index)
-        "message:#{index}"
+      def tree_contains_active_path?(node, active_path)
+        entry_id = (node[:source]["entry"] || {})["id"].to_s
+        active_path.include?(entry_id) || node[:children].any? { |child| tree_contains_active_path?(child, active_path) }
+      end
+
+      def tree_tool_calls(roots)
+        roots.each_with_object({}) do |root, tool_calls_by_id|
+          stack = [root]
+          until stack.empty?
+            node = stack.pop
+            entry = node["entry"] || {}
+            message = entry["message"]
+            if entry["type"] == "message" && message.is_a?(Hash) && message_role(message) == "assistant"
+              tool_calls(message).each { |tool_call| tool_calls_by_id[ToolCall.id(tool_call).to_s] = tool_call }
+            end
+            stack.concat(Array(node["children"]))
+          end
+        end
       end
 
-      def entry_index(entry_id)
-        match = entry_id.to_s.match(/\Amessage:(\d+)\z/)
-        raise ArgumentError, "Invalid entryId: #{entry_id}" unless match
+      def tree_entry_display(entry, tool_calls_by_id = {})
+        case entry["type"]
+        when "message"
+          message = entry["message"] || {}
+          role = message_role(message).to_s
+          return { role: "tool", text: format_tool_result(message, tool_calls_by_id) } if ["tool", "toolResult"].include?(role)
+          return { role: role.empty? ? "message" : role, text: display_message_text(message) }
+        when "compaction"
+          return { role: "compaction", text: display_message_text(entry["message"] || {}) }
+        when "branch_summary"
+          return { role: "summary", text: truncate_tree_text(entry["summary"]) }
+        end
 
-        match[1].to_i
+        { role: entry["type"].to_s.empty? ? "entry" : entry["type"].to_s, text: entry["type"].to_s }
+      end
+
+      def tree_prefix(display_indent, gutters, show_connector, is_last, foldable)
+        return "" if display_indent.to_i <= 0
+
+        connector_position = show_connector ? display_indent - 1 : -1
+        (0...(display_indent * 3)).map do |index|
+          level = index / 3
+          position = index % 3
+          gutter = gutters.find { |candidate| candidate[:position] == level }
+
+          if gutter
+            position.zero? && gutter[:show] ? "│" : " "
+          elsif show_connector && level == connector_position
+            if position.zero?
+              is_last ? "└" : "├"
+            elsif position == 1
+              foldable ? "⊟" : "─"
+            else
+              " "
+            end
+          else
+            " "
+          end
+        end.join
+      end
+
+      def format_tool_result(message, tool_calls_by_id)
+        tool_call = tool_calls_by_id[tree_message_tool_call_id(message).to_s]
+        return format_tool_call(tool_call) if tool_call
+
+        name = tree_message_tool_name(message).to_s
+        name = "tool" if name.empty?
+        "[#{name}]"
+      end
+
+      def tree_message_tool_call_id(message)
+        MessageAccess.tool_call_id(message) || ToolCall.value(message, :toolCallId)
+      end
+
+      def tree_message_tool_name(message)
+        MessageAccess.name(message) || ToolCall.value(message, :toolName)
+      end
+
+      def format_tool_call(tool_call)
+        name = ToolCall.display_name(tool_call)
+        args = ToolCall.arguments(tool_call)
+        case name
+        when "read"
+          path = args["path"] || args[:path] || args["file_path"] || args[:file_path]
+          offset = args["offset"] || args[:offset]
+          limit = args["limit"] || args[:limit]
+          display = path.to_s
+          if offset || limit
+            start_line = offset || 1
+            end_line = limit ? start_line.to_i + limit.to_i - 1 : nil
+            display += ":#{start_line}#{end_line ? "-#{end_line}" : ""}"
+          end
+          "[read: #{display}]"
+        when "write", "edit"
+          path = args["path"] || args[:path] || args["file_path"] || args[:file_path]
+          "[#{name}: #{path}]"
+        when "bash"
+          command = (args["command"] || args[:command]).to_s.gsub(/[\n\t]/, " ").strip
+          "[bash: #{command.length > 50 ? "#{command.slice(0, 50)}..." : command}]"
+        else
+          serialized = JSON.dump(args)
+          "[#{name}: #{serialized.length > 40 ? "#{serialized.slice(0, 40)}..." : serialized}]"
+        end
+      end
+
+      def summarize_branch(rpc_session, from_id:, to_id:, custom_instructions: nil)
+        entries = tree_entries(rpc_session)
+        active = active_path_ids(entries, from_id)
+        target = active_path_ids(entries, to_id)
+        target_lookup = target.to_h { |id| [id, true] }
+        abandoned = active.reject { |id| target_lookup[id] }
+        messages = entries.select { |entry| abandoned.include?(entry["id"].to_s) }.filter_map { |entry| entry["message"] }
+        source_text = messages.map { |message| "#{message_role(message)}: #{full_message_text(message)}" }.join("\n\n")
+        prompt = [
+          { role: "system", content: "Summarize the abandoned conversation branch concisely for future context." },
+          { role: "user", content: [custom_instructions.to_s.strip, source_text].reject(&:empty?).join("\n\n") }
+        ]
+        response = @client.chat(prompt, tools: [])
+        text = full_message_text(response)
+        text.empty? ? "Branch summary unavailable." : text
       end
 
       def display_message_text(message)
-        full_message_text(message).gsub(/\s+/, " ").strip.slice(0, 120).to_s
+        truncate_tree_text(full_message_text(message))
+      end
+
+      def truncate_tree_text(text)
+        normalized = text.to_s.gsub(/\s+/, " ").strip
+        normalized.length > 120 ? "#{normalized.slice(0, 117)}..." : normalized
       end
 
       def full_message_text(message)
@@ -716,23 +1021,23 @@ module Kward
       def normalize_attachment(attachment)
         raise ArgumentError, "attachment must be an object" unless attachment.is_a?(Hash)
 
-        type = value(attachment, :type).to_s
+        type = ToolCall.value(attachment, :type).to_s
         raise ArgumentError, "Unsupported attachment type: #{type.empty? ? "unknown" : type}" unless type == "image"
 
-        mime_type = normalize_attachment_mime_type(value(attachment, :mimeType) || value(attachment, :mime_type) || value(attachment, :media_type))
+        mime_type = normalize_attachment_mime_type(ToolCall.value(attachment, :mimeType) || ToolCall.value(attachment, :mime_type) || ToolCall.value(attachment, :media_type))
         raise ArgumentError, "Unsupported image MIME type: #{mime_type.empty? ? "unknown" : mime_type}" unless RPC_IMAGE_MIME_TYPES.include?(mime_type)
 
-        data = value(attachment, :data).to_s
+        data = ToolCall.value(attachment, :data).to_s
         raise ArgumentError, "Image attachment data must be valid base64" if data.empty?
         raise ArgumentError, "Image attachment data must be raw base64" if data.start_with?("data:")
-        declared_size = value(attachment, :sizeBytes) || value(attachment, :size_bytes)
+        declared_size = ToolCall.value(attachment, :sizeBytes) || ToolCall.value(attachment, :size_bytes)
         raise ArgumentError, "Image attachment is too large" if declared_size && declared_size.to_i > RPC_ATTACHMENT_MAX_BYTES
 
         decoded_size = Base64.strict_decode64(data).bytesize
         raise ArgumentError, "Image attachment is too large" if decoded_size > RPC_ATTACHMENT_MAX_BYTES
 
         result = { type: "image", data: data, mimeType: mime_type }
-        name = value(attachment, :name)
+        name = ToolCall.value(attachment, :name)
         result[:alt] = name.to_s unless name.to_s.empty?
         result
       rescue ArgumentError => e
@@ -745,14 +1050,6 @@ module Kward
         mime_type.to_s.downcase
       end
 
-      def value(object, key)
-        return nil unless object.respond_to?(:key?)
-        return object[key] if object.key?(key)
-        return object[key.to_s] if object.key?(key.to_s)
-
-        nil
-      end
-
       def plugin_registry
         @plugin_registry ||= PluginRegistry.load(reserved_commands: reserved_plugin_command_names)
       end
@@ -788,11 +1085,29 @@ module Kward
       end
 
       def build_tool_registry(workspace_root, prompt)
-        ToolRegistry.new(workspace: Workspace.new(root: workspace_root), prompt: prompt)
+        ToolRegistry.new(workspace: configured_workspace(workspace_root), prompt: prompt)
+      end
+
+      def configured_workspace(root)
+        Workspace.new(root: root, guardrails: workspace_guardrails_enabled?)
+      end
+
+      def workspace_guardrails_enabled?
+        ConfigFiles.workspace_guardrails_enabled?(ConfigFiles.read_config(config_path))
+      end
+
+      def session_auto_resume_enabled?
+        ConfigFiles.session_auto_resume_enabled?(ConfigFiles.read_config(config_path))
+      end
+
+      def config_path
+        File.join(@config_dir, "config.json")
       end
 
       def remember_session(rpc_session)
         @mutex.synchronize { @sessions[rpc_session.id] = rpc_session }
+        rpc_session.store.remember_last_session(rpc_session.session) if rpc_session.store.respond_to?(:remember_last_session)
+        start_footer_worker(rpc_session)
       end
 
       def fetch_session(session_id)
@@ -809,10 +1124,11 @@ module Kward
         rpc_session.worker = Thread.new { worker_loop(rpc_session) }
       end
 
-      def close_rpc_session(rpc_session)
+      def close_rpc_session(rpc_session, delete_unused: true)
         @mutex.synchronize { @sessions.delete(rpc_session.id) }
         stop_worker(rpc_session)
-        rpc_session.session.delete_if_unused if rpc_session.session.respond_to?(:delete_if_unused)
+        stop_footer_worker(rpc_session)
+        rpc_session.session.delete_if_unused if delete_unused && rpc_session.session.respond_to?(:delete_if_unused)
       end
 
       def cleanup_other_unused_sessions(current_session)
@@ -826,6 +1142,7 @@ module Kward
 
           @mutex.synchronize { @sessions.delete(rpc_session.id) }
           stop_worker(rpc_session)
+          stop_footer_worker(rpc_session)
         end
       end
 
@@ -837,6 +1154,34 @@ module Kward
         rpc_session.queue << WORKER_STOP
       end
 
+      def start_footer_worker(rpc_session)
+        return unless plugin_registry.footer_renderer
+        return if rpc_session.footer_worker&.alive?
+
+        rpc_session.footer_worker = Thread.new do
+          loop do
+            sleep FOOTER_REFRESH_INTERVAL
+            break unless @mutex.synchronize { @sessions[rpc_session.id] == rpc_session }
+
+            emit_footer_update(rpc_session)
+          end
+        rescue StandardError => e
+          @server.log_error(e)
+        ensure
+          rpc_session.footer_worker = nil if rpc_session.footer_worker == Thread.current
+        end
+      end
+
+      def stop_footer_worker(rpc_session)
+        worker = rpc_session.footer_worker
+        rpc_session.footer_worker = nil
+        return unless worker&.alive?
+        return if worker == Thread.current
+
+        worker.kill
+        worker.join(0.1)
+      end
+
       def worker_loop(rpc_session)
         loop do
           turn_id = rpc_session.queue.pop
@@ -870,8 +1215,9 @@ module Kward
         if turn.plugin_command_name
           run_plugin_turn(rpc_session, turn)
         else
+          auto_name_session(rpc_session, turn.display_input || turn.input)
           prepare_memory_context(rpc_session.conversation, turn.input)
-          rpc_session.agent.ask(turn.input, cancellation: turn.cancellation, steering: turn.steering) do |event|
+          rpc_session.agent.ask(turn.input, display_input: turn_display_input(turn), cancellation: turn.cancellation, steering: turn.steering) do |event|
             next if turn.cancel_requested
 
             notify_plugin_transcript_event(rpc_session, event)
@@ -895,6 +1241,24 @@ module Kward
         Steering.new
       end
 
+      def auto_name_session(rpc_session, input)
+        return unless rpc_session.session.name.to_s.strip.empty?
+
+        name = default_session_name(input)
+        rpc_session.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 turn_display_input(turn)
+        return nil if turn.display_input.nil?
+        return nil if turn.display_input == turn.input
+
+        turn.display_input
+      end
+
       def prepare_memory_context(conversation, input)
         manager = memory_manager
         retrieval = manager.retrieve_relevant(input: input, workspace_root: conversation.workspace_root)
@@ -994,6 +1358,30 @@ module Kward
         turn.status = status
         turn.finished_at = now
         emit_turn_event(turn, "turnFinished", { status: status, error: turn.error })
+        rpc_session = @mutex.synchronize { @sessions[turn.session_id] }
+        emit_footer_update(rpc_session) if rpc_session
+      end
+
+      def emit_footer_update(rpc_session)
+        renderer = plugin_registry.footer_renderer
+        return unless renderer
+
+        text = begin
+          context = PluginRegistry::Context.new(
+            conversation: rpc_session.conversation,
+            session: rpc_session.session,
+            workspace_root: rpc_session.workspace_root,
+            say_callback: lambda { |message| rpc_session.plugin_output << message.to_s }
+          )
+          renderer.call(context).to_s.gsub(/\s+/, " ").strip
+        rescue StandardError => e
+          warn "Warning: Kward plugin footer error: #{e.message}"
+          ""
+        end
+        return if rpc_session.last_footer_text == text
+
+        rpc_session.last_footer_text = text
+        @server.notify("ui/footer", { sessionId: rpc_session.id, text: text })
       end
 
       def emit_turn_event(turn, type, payload)
@@ -1069,11 +1457,11 @@ module Kward
       end
 
       def normalized_tool_event_payload(tool_call)
-        ToolEventNormalizer.new(tool_call).call_payload(legacy_tool: tool_metadata(tool_call))
+        ToolEventNormalizer.new(tool_call).call_payload
       end
 
       def normalized_tool_result_event_payload(tool_call, content)
-        ToolEventNormalizer.new(tool_call, content: content).result_payload(legacy_tool: tool_metadata(tool_call))
+        ToolEventNormalizer.new(tool_call, content: content).result_payload
       end
 
       def turn_error_payload(error)
@@ -1084,35 +1472,6 @@ module Kward
         }
       end
 
-      def tool_metadata(tool_call)
-        name = ToolCall.name(tool_call)
-        args = ToolCall.arguments(tool_call)
-
-        case name
-        when "edit_file"
-          edits = Array(args["edits"] || args[:edits]).map do |edit|
-            {
-              oldText: edit["old_text"] || edit[:old_text],
-              newText: edit["new_text"] || edit[:new_text]
-            }.compact
-          end
-          first_edit = edits.first || {}
-          {
-            kind: "edit",
-            path: args["path"] || args[:path],
-            edits: edits,
-            oldText: first_edit[:oldText],
-            newText: first_edit[:newText]
-          }.compact
-        when "write_file"
-          { kind: "write", path: args["path"] || args[:path] }.compact
-        when "run_shell_command"
-          { kind: "shell", command: args["command"] || args[:command] }.compact
-        else
-          nil
-        end
-      end
-
 
       def now
         Time.now.utc.iso8601(3)