kward 0.70.0 → 0.72.0

data/lib/kward/prompts.rb

@@ -32,9 +32,11 @@ module Kward
 
     def base_prompt
       <<~PROMPT.strip
-        You are Kward, a concise practical CLI coding agent. You are allowed to use the tools. Help users understand and modify software projects. Inspect files before changing them, make the smallest correct change, preserve existing style, and summarize what changed. Be honest about limitations.
+        You are Kward, a concise practical CLI coding agent. Use tools to understand and modify software projects. Inspect files before changing them, make the smallest correct change, preserve existing style, and summarize what changed. Be honest about limitations.
 
-        For web research, use web_search to discover sources, then fetch_content for important human-readable pages before relying on them. Use fetch_raw for machine-readable resources such as JSON, YAML, XML, RSS, OpenAPI specs, and plain text. Prefer official or primary sources when practical, and cite or mention the URLs you relied on.
+        For web research, use web_search to discover sources, fetch_content for important human-readable pages, and fetch_raw for machine-readable resources such as JSON, YAML, XML, RSS, OpenAPI specs, and plain text. Prefer official or primary sources and cite or mention the URLs you relied on.
+
+        Manage code context deliberately. Prefer context_for_task, summarize_file_structure, and read_file mode="outline"/"preview" before broad reads. Escalate to read_file mode="range" for exact lines, and use mode="full" only when focused context is insufficient. Use context_budget_stats when asked about context savings.
       PROMPT
     end
 

data/lib/kward/rpc/server.rb

@@ -5,6 +5,7 @@ require_relative "../memory/manager"
 require_relative "../plugin_registry"
 require_relative "../prompts/commands"
 require_relative "../tools/registry"
+require_relative "../workers"
 require_relative "../workspace"
 require_relative "../telemetry/logger"
 require_relative "../telemetry/stats"
@@ -49,7 +50,7 @@ module Kward
         "sessions/tree", "sessions/tree/setLabel", "sessions/tree/navigate",
         "sessions/export", "sessions/delete", "sessions/close", "sessions/transcript"
       ].freeze
-      MODEL_METHODS = ["models/list", "models/current", "models/set", "reasoning/set", "openrouter/catalog"].freeze
+      MODEL_METHODS = ["models/list", "models/current", "models/set", "reasoning/set"].freeze
       AUTH_METHODS = [
         "auth/status", "auth/providers", "auth/loginWithApiKey", "auth/logoutProvider",
         "auth/loginWithOAuth", "auth/startOpenAILogin", "auth/submitOpenAICode", "auth/loginStatus"
@@ -60,14 +61,18 @@ module Kward
         "memory/forget", "memory/promote", "memory/relax", "memory/inspect",
         "memory/why", "memory/summarize"
       ].freeze
+      WORKER_METHODS = ["workers/list", "workers/show"].freeze
 
       # Creates the RPC server and its stateful managers.
-      def initialize(input: $stdin, output: $stdout, error_output: $stderr, client: Client.new)
+      def initialize(input: $stdin, output: $stdout, error_output: $stderr, client: Client.new, experimental_workers: false)
         @transport = Transport.new(input: input, output: output)
         @error_output = error_output
+        @client = client
         @config_manager = ConfigManager.new
         @session_manager = SessionManager.new(server: self, client: client, config_manager: @config_manager)
         @auth_manager = AuthManager.new(server: self, config_manager: @config_manager)
+        @worker_store = Workers::Store.new
+        @experimental_workers = experimental_workers
         @shutdown = false
       end
 
@@ -88,7 +93,7 @@ module Kward
           end
         end
       ensure
-        @session_manager.cleanup_unused_sessions
+        @session_manager.shutdown_sessions
       end
 
       # Sends a redacted JSON-RPC notification to the client.
@@ -166,8 +171,6 @@ module Kward
           prompts_expand(params)
         when "models/list"
           models_list
-        when "openrouter/catalog"
-          openrouter_catalog
         when "models/current"
           models_current
         when "models/set"
@@ -224,6 +227,12 @@ module Kward
           @session_manager.memory_why(session_id: params["sessionId"])
         when "memory/summarize"
           @session_manager.memory_summarize(session_id: params.fetch("sessionId"))
+        when "workers/list"
+          require_experimental_workers!
+          workers_list(params)
+        when "workers/show"
+          require_experimental_workers!
+          workers_show(params)
         when "auth/status"
           @auth_manager.status
         when "auth/providers"
@@ -345,7 +354,7 @@ module Kward
             reasoning: { start: false, delta: true, end: false },
             modelRetry: { supported: true, event: "modelRetry" },
             steering: { supported: @session_manager.in_flight_steer_supported?, event: "turnSteered", mode: @session_manager.in_flight_steer_supported? ? "native" : "unsupported" },
-            tools: { call: true, update: false, result: true, normalizedMetadata: true, diffs: true, changedFiles: false, workspaceGuardrails: workspace_guardrails_enabled? },
+            tools: { call: true, update: false, result: true, normalizedMetadata: true, diffs: true, changedFiles: false, workspaceGuardrails: workspace_guardrails_enabled?, focusedContext: true, contextBudgetStats: true },
             errors: true,
             sessionUpdates: false
           },
@@ -362,7 +371,8 @@ module Kward
             supported: true,
             methods: MODEL_METHODS,
             fields: ["provider", "id", "name", "reasoning", "reasoningEffort", "contextWindow"],
-            scopedModels: false
+            scopedModels: false,
+            openRouterRefresh: { supported: false, reason: "cliOnlyCacheRefresh" }
           },
           runtime: {
             supported: true,
@@ -385,9 +395,11 @@ module Kward
             logout: true
           },
           memory: { supported: true, optIn: true, defaultEnabled: false, autoSummaryDefaultEnabled: false, promptInjection: "interactive", storage: { core: "json", soft: "jsonl", events: "jsonl" }, methods: MEMORY_METHODS },
+          workers: workers_capability,
           commands: { supported: true, methods: ["commands/list", "commands/run"], method: "commands/list", runMethod: "commands/run", sources: ["builtin", "prompt", "skill", "plugin"], executableSources: ["builtin", "plugin"] },
           startupResources: { supported: true, method: "resources/startup" },
           starterPack: { supported: false, reason: "cliOnlyInstallCommand" },
+          shell: { supported: false, reason: "interactiveTuiOnly" },
           extensionUi: {
             question: { supported: true, notification: "ui/question", method: "ui/answerQuestion", maxQuestions: 4, multiSelect: false, preview: false },
             select: false,
@@ -427,6 +439,18 @@ module Kward
         }
       end
 
+      def workers_capability
+        return { supported: false, reason: "experimentalWorkersFlagRequired", flag: "--experimental-workers" } unless @experimental_workers
+
+        { supported: true, methods: WORKER_METHODS, roles: ["implementation", "request"], statuses: Workers::Worker::STATUSES, transcriptStorage: "sessions", metadataStorage: "json" }
+      end
+
+      def require_experimental_workers!
+        return if @experimental_workers
+
+        raise NoMethodError, "workers require --experimental-workers"
+      end
+
       def workspace_info(root)
         root = @session_manager.validate_workspace_root(root)
         { root: root, basename: File.basename(root), writable: File.writable?(root) }
@@ -458,10 +482,6 @@ module Kward
         { models: @session_manager.available_models }
       end
 
-      def openrouter_catalog
-        { models: @session_manager.openrouter_catalog }
-      end
-
       def config_update(params)
         config = @config_manager.update(params.fetch("values"))
         @session_manager.refresh_client_config
@@ -576,6 +596,20 @@ module Kward
         { sections: sections }
       end
 
+      def workers_list(params)
+        include_archived = params["includeArchived"] == true
+        workers = @worker_store.list(include_archived: include_archived)
+        { workers: workers }
+      end
+
+      def workers_show(params)
+        id = params.fetch("id").to_s.delete_prefix("#")
+        worker = @worker_store.find(id)
+        return { worker: worker } if worker
+
+        raise ArgumentError, "Unknown worker: #{id}"
+      end
+
       def auth_login_with_api_key(params)
         result = @auth_manager.login_with_api_key(provider_id: params.fetch("providerId"), api_key: params.fetch("apiKey"))
         @session_manager.refresh_client_config

data/lib/kward/rpc/session_manager.rb

@@ -295,12 +295,21 @@ module Kward
         rpc_sessions = @mutex.synchronize { @sessions.values.dup }
         rpc_sessions.reverse_each do |rpc_session|
           next unless session_idle?(rpc_session)
+          next unless rpc_session.session.respond_to?(:delete_if_unused)
+          next unless rpc_session.session.delete_if_unused
 
-          close_rpc_session(rpc_session)
+          remove_live_session(rpc_session)
         end
         { closed: true }
       end
 
+      # Stops all live RPC session workers during server shutdown.
+      def shutdown_sessions
+        rpc_sessions = @mutex.synchronize { @sessions.values.dup }
+        rpc_sessions.reverse_each { |rpc_session| close_rpc_session(rpc_session) if session_idle?(rpc_session) }
+        { closed: true }
+      end
+
       # Returns the normalized transcript for the active RPC session.
       def transcript(session_id:)
         rpc_session = fetch_session(session_id)
@@ -321,10 +330,7 @@ module Kward
         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"
-          steered_turn = steer_running_turn(rpc_session, content)
-          return steered_turn if steered_turn
-
-          streaming_behavior = "followUp"
+          return steer_running_turn(rpc_session, content)
         end
         turn = Turn.new(
           id: SecureRandom.uuid,
@@ -461,13 +467,7 @@ module Kward
         rpc_session = fetch_session(session_id)
         command = plugin_registry.command_for(command.to_s.delete_prefix("/")) || raise(ArgumentError, "Unknown plugin command: #{command}")
         output = []
-        context = PluginRegistry::Context.new(
-          conversation: rpc_session.conversation,
-          args: arguments.to_s,
-          session: rpc_session.session,
-          workspace_root: rpc_session.workspace_root,
-          say_callback: lambda { |message| output << message.to_s }
-        )
+        context = plugin_context(rpc_session, args: arguments.to_s, say_callback: lambda { |message| output << message.to_s })
         result = command.handler.call(arguments.to_s, context)
         output = rpc_session.plugin_output.shift(rpc_session.plugin_output.length) + output
         { command: command.name, output: output, result: result.nil? ? nil : result.to_s }
@@ -485,11 +485,6 @@ module Kward
         normalized
       end
 
-      def openrouter_catalog
-        models = @client.respond_to?(:openrouter_catalog) ? Array(@client.openrouter_catalog) : []
-        models.map { |model| normalize_model(model) }
-      end
-
       def current_model
         provider = @client.respond_to?(:current_provider) ? @client.current_provider : nil
         model = @client.respond_to?(:current_model) ? @client.current_model : nil
@@ -503,7 +498,7 @@ module Kward
         model = rpc_session.conversation.model || current[:id]
         reasoning_effort = rpc_session.conversation.reasoning_effort || current_reasoning_effort
         reasoning_effort = nil unless ModelInfo.reasoning_supported?(provider, model)
-        context_window = current[:contextWindow] if provider == current[:provider] && model == current[:id]
+        context_window = context_window_for(provider, model)
         normalize_model(
           provider: provider,
           id: model,
@@ -666,6 +661,11 @@ module Kward
       end
 
       def normalize_model(model)
+        unless model.key?(:contextWindow) || model.key?("contextWindow")
+          provider = model[:provider] || model["provider"]
+          id = model[:id] || model["id"] || model[:model] || model["model"]
+          model = model.merge(contextWindow: context_window_for(provider, id))
+        end
         ModelInfo.normalize(
           model,
           current_provider: (@client.current_provider if @client.respond_to?(:current_provider)),
@@ -674,6 +674,17 @@ module Kward
         )
       end
 
+      def context_window_for(provider, model)
+        provider = ModelInfo.provider_label(provider)
+        return @client.context_window(provider, model) if @client.respond_to?(:context_window) && @client.method(:context_window).arity != 0
+
+        if @client.respond_to?(:current_context_window) && @client.respond_to?(:current_provider) && @client.respond_to?(:current_model)
+          return @client.current_context_window if provider == @client.current_provider && model == @client.current_model
+        end
+
+        ModelInfo.context_window(provider, model)
+      end
+
       def active_persona_label(rpc_session)
         ConfigFiles.active_persona_label(
           workspace_root: rpc_session.workspace_root,
@@ -698,10 +709,6 @@ module Kward
         pending_turn_count(rpc_session.id).zero?
       end
 
-      def active_session_count(workspace_root)
-        @mutex.synchronize { @sessions.values.count { |rpc_session| rpc_session.workspace_root == workspace_root } }
-      end
-
       def tool_calls(message)
         MessageAccess.tool_calls(message)
       end
@@ -710,10 +717,6 @@ module Kward
         MessageAccess.role(message)
       end
 
-      def message_content(message)
-        MessageAccess.content(message)
-      end
-
       def session_tree_helper(rpc_session)
         SessionTree.new(rpc_session)
       end
@@ -902,9 +905,7 @@ module Kward
       end
 
       def close_rpc_session(rpc_session, delete_unused: true)
-        @mutex.synchronize { @sessions.delete(rpc_session.id) }
-        stop_worker(rpc_session)
-        stop_footer_worker(rpc_session)
+        remove_live_session(rpc_session)
         rpc_session.session.delete_if_unused if delete_unused && rpc_session.session.respond_to?(:delete_if_unused)
       end
 
@@ -917,12 +918,16 @@ module Kward
           next unless rpc_session.session.respond_to?(:delete_if_unused)
           next unless rpc_session.session.delete_if_unused
 
-          @mutex.synchronize { @sessions.delete(rpc_session.id) }
-          stop_worker(rpc_session)
-          stop_footer_worker(rpc_session)
+          remove_live_session(rpc_session)
         end
       end
 
+      def remove_live_session(rpc_session)
+        @mutex.synchronize { @sessions.delete(rpc_session.id) }
+        stop_worker(rpc_session)
+        stop_footer_worker(rpc_session)
+      end
+
       def stop_worker(rpc_session)
         worker = rpc_session.worker
         return unless worker&.alive?
@@ -1065,21 +1070,23 @@ module Kward
 
         turn.steering.submit(input)
         turn_payload(turn)
-      rescue StandardError
-        nil
       end
 
-      def run_plugin_turn(rpc_session, turn)
-        turn.cancellation&.raise_if_cancelled!
-        command = plugin_registry.command_for(turn.plugin_command_name) || raise(ArgumentError, "Unknown plugin command: #{turn.plugin_command_name}")
-        output = []
-        context = PluginRegistry::Context.new(
+      def plugin_context(rpc_session, args: nil, say_callback:)
+        PluginRegistry::Context.new(
           conversation: rpc_session.conversation,
-          args: turn.plugin_arguments.to_s,
+          args: args,
           session: rpc_session.session,
           workspace_root: rpc_session.workspace_root,
-          say_callback: lambda { |message| output << message.to_s }
+          say_callback: say_callback
         )
+      end
+
+      def run_plugin_turn(rpc_session, turn)
+        turn.cancellation&.raise_if_cancelled!
+        command = plugin_registry.command_for(turn.plugin_command_name) || raise(ArgumentError, "Unknown plugin command: #{turn.plugin_command_name}")
+        output = []
+        context = plugin_context(rpc_session, args: turn.plugin_arguments.to_s, say_callback: lambda { |message| output << message.to_s })
         result = command.handler.call(turn.plugin_arguments.to_s, context)
         answer = (output + [result]).compact.map(&:to_s).reject(&:empty?).join("\n")
         unless answer.empty?
@@ -1092,12 +1099,7 @@ module Kward
       def notify_plugin_transcript_event(rpc_session, event)
         return if plugin_registry.transcript_event_handlers.empty?
 
-        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 }
-        )
+        context = plugin_context(rpc_session, say_callback: lambda { |message| rpc_session.plugin_output << message.to_s })
         plugin_registry.notify_transcript_event(event, context)
       end
 
@@ -1113,6 +1115,8 @@ module Kward
           emit_turn_event(turn, "modelRetry", retry_event_payload(event))
         when Events::Steering
           emit_turn_event(turn, "turnSteered", { input: event.input, createdAt: event.created_at })
+        when Events::SteeringApplied
+          emit_turn_event(turn, "steeringApplied", { count: event.count })
         when Events::ToolCall
           emit_turn_event(turn, "toolCall", normalized_tool_event_payload(event.tool_call))
         when Events::ToolResult
@@ -1149,12 +1153,7 @@ module Kward
         return clear_footer_update(rpc_session) 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 }
-          )
+          context = plugin_context(rpc_session, 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}"

data/lib/kward/rpc/session_tree_rows.rb

@@ -1,7 +1,7 @@
 require_relative "../message_access"
 require_relative "../message_text"
+require_relative "../session_tree_nodes"
 require_relative "../session_tree_tool_display"
-require_relative "../tools/tool_call"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -28,13 +28,14 @@ module Kward
       #
       # @return [Array<Hash>] rows for the `session/tree` RPC method
       def rows
-        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) }
+        tree_nodes = SessionTreeNodes.new(roots: @roots, current_leaf: @current_leaf)
+        active_path = tree_nodes.active_path
+        tool_calls_by_id = tree_nodes.tool_calls
+        visible_roots = tree_nodes.visible_roots
         multiple_roots = visible_roots.length > 1
         result = []
 
-        stack = visible_roots.sort_by { |root| tree_contains_active_path?(root, active_path) ? 0 : 1 }.each_with_index.map do |root, index|
+        stack = visible_roots.sort_by { |root| tree_nodes.contains_active_path?(root, active_path) ? 0 : 1 }.each_with_index.map do |root, index|
           [root, multiple_roots ? 1 : 0, multiple_roots, multiple_roots, index == visible_roots.length - 1, [], multiple_roots]
         end.reverse
 
@@ -60,7 +61,7 @@ module Kward
             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 }
+          children = node[:children].sort_by { |child| tree_nodes.contains_active_path?(child, active_path) ? 0 : 1 }
           multiple_children = children.length > 1
           child_indent = if multiple_children
                            indent + 1
@@ -80,112 +81,6 @@ module Kward
 
       private
 
-      def tree_active_path(roots, leaf_id)
-        by_id = tree_entries_by_id(roots)
-        ids = []
-        current = by_id[leaf_id.to_s]
-        seen = {}
-        while current && !seen[current["id"].to_s]
-          seen[current["id"].to_s] = true
-          ids << current["id"].to_s
-          current = by_id[current["parentId"].to_s]
-        end
-        ids
-      end
-
-      def tree_entries_by_id(roots)
-        roots.each_with_object({}) do |root, map|
-          stack = [root]
-          seen = {}
-          until stack.empty?
-            node = stack.pop
-            next if seen[node.object_id]
-
-            seen[node.object_id] = true
-            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)
-        results = {}
-        stack = [[node, false, {}]]
-
-        until stack.empty?
-          current, visited, seen = stack.pop
-          node_key = current.object_id
-          next if seen[node_key]
-
-          if visited
-            children = Array(current["children"]).flat_map { |child| results[child.object_id] || [] }
-            results[node_key] = if hidden_tree_entry?(current["entry"] || {})
-                                  children
-                                else
-                                  [{ source: current, children: children }]
-                                end
-          else
-            branch_seen = seen.merge(node_key => true)
-            stack << [current, true, seen]
-            Array(current["children"]).reverse_each { |child| stack << [child, false, branch_seen] unless branch_seen[child.object_id] }
-          end
-        end
-
-        results[node.object_id] || []
-      end
-
-      def hidden_tree_entry?(entry)
-        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) && MessageAccess.role(message) == "assistant"
-
-        content = MessageAccess.content(message)
-        content_tool_calls = content.is_a?(Array) && content.any? { |part| ToolCall.value(part, :type) == "toolCall" }
-        (content_tool_calls && !tree_text_content?(content)) || (!MessageAccess.tool_calls(message).empty? && MessageText.full_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 tree_contains_active_path?(node, active_path)
-        stack = [node]
-        seen = {}
-        until stack.empty?
-          current = stack.pop
-          next if seen[current.object_id]
-
-          seen[current.object_id] = true
-          entry_id = (current[:source]["entry"] || {})["id"].to_s
-          return true if active_path.include?(entry_id)
-
-          stack.concat(current[:children])
-        end
-        false
-      end
-
-      def tree_tool_calls(roots)
-        roots.each_with_object({}) do |root, tool_calls_by_id|
-          stack = [root]
-          seen = {}
-          until stack.empty?
-            node = stack.pop
-            next if seen[node.object_id]
-
-            seen[node.object_id] = true
-            entry = node["entry"] || {}
-            message = entry["message"]
-            if entry["type"] == "message" && message.is_a?(Hash) && MessageAccess.role(message) == "assistant"
-              MessageAccess.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 tree_entry_display(entry, tool_calls_by_id = {})
         case entry["type"]
         when "message"
@@ -237,12 +132,11 @@ module Kward
       end
 
       def display_message_text(message)
-        truncate_tree_text(MessageText.full_text(message))
+        SessionTreeNodes.truncate_text(MessageText.full_text(message))
       end
 
       def truncate_tree_text(text)
-        normalized = text.to_s.gsub(/\s+/, " ").strip
-        normalized.length > 120 ? "#{normalized.slice(0, 117)}..." : normalized
+        SessionTreeNodes.truncate_text(text)
       end
     end
   end

data/lib/kward/rpc/tool_event_normalizer.rb

@@ -67,7 +67,7 @@ module Kward
       end
 
       def mutation_tool?
-        ["edit", "write"].include?(@fields[:toolName])
+        ToolCall.file_change_tool?(@fields[:toolName])
       end
     end
   end

data/lib/kward/session_store.rb

@@ -178,6 +178,9 @@ module Kward
     # @return [String] workspace directory this store lists and creates sessions for
     attr_reader :cwd
 
+    # @return [String] configuration directory containing session and tab files
+    attr_reader :config_dir
+
     # Creates a new empty session file for the store's workspace directory.
     #
     # Parent fields record clone/fork ancestry; they do not imply live coupling
@@ -285,6 +288,7 @@ module Kward
         session_memories: memory_state["sessionMemories"],
         last_memory_retrieval: memory_state["lastRetrieval"]
       )
+      restore_tool_output_artifacts(records, conversation)
       conversation.mark_last_entry_compaction! if latest_record_type(records) == "compaction"
       session = Session.new(
         store: self,
@@ -496,9 +500,29 @@ module Kward
 
     def session_header(records, path)
       header = records.find { |record| record["type"] == "session" }
-      raise "Invalid Kward session file: #{path}" unless header && header["id"].to_s != ""
+      return header if header && header["id"].to_s != ""
+
+      recovered = recovered_session_header(records, path)
+      return recovered if recovered
 
-      header
+      raise "Invalid Kward session file: #{path}"
+    end
+
+    def recovered_session_header(records, path)
+      return nil unless records.any? { |record| ["message", "session_info", "system_prompt", "memory_state"].include?(record["type"]) }
+
+      basename = File.basename(path)
+      match = basename.match(/\A(?<timestamp>\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}\.\d{3}Z)_(?<id>[0-9a-fA-F-]{36})\.jsonl\z/)
+      return nil unless match
+
+      timestamp = match[:timestamp].tr("-", ":").sub(/\A(\d{4}):(\d{2}):(\d{2})T/, "\\1-\\2-\\3T")
+      {
+        "type" => "session",
+        "version" => VERSION,
+        "id" => match[:id],
+        "timestamp" => timestamp,
+        "cwd" => @cwd
+      }
     end
 
     def session_named?(session)
@@ -541,6 +565,46 @@ module Kward
       records.reverse.find { |record| record["type"] == "memory_state" } || { "sessionMemories" => [], "lastRetrieval" => nil }
     end
 
+    def restore_tool_output_artifacts(records, conversation)
+      tool_names = tool_message_names_by_id(records)
+      records.each do |record|
+        next unless record["type"] == "tool_execution_end"
+
+        content = record.dig("result", "content")
+        next if content.nil?
+
+        tool_name = tool_names[record["toolCallId"].to_s] || raw_tool_name(record["toolName"])
+        next if tool_name.to_s.empty?
+
+        conversation.restore_tool_output_artifact(
+          tool_name: tool_name,
+          content: content,
+          created_at: parse_time(record["timestamp"])
+        )
+      end
+    end
+
+    def tool_message_names_by_id(records)
+      records.each_with_object({}) do |record, names|
+        next unless record["type"] == "message"
+
+        message = record["message"]
+        next unless message.is_a?(Hash) && message_role(message) == "tool"
+
+        tool_call_id = message_tool_call_id(message).to_s
+        names[tool_call_id] = message_name(message) unless tool_call_id.empty? || message_name(message).to_s.empty?
+      end
+    end
+
+    def raw_tool_name(name)
+      {
+        "bash" => "run_shell_command",
+        "edit" => "edit_file",
+        "read" => "read_file",
+        "write" => "write_file"
+      }.fetch(name.to_s, name.to_s)
+    end
+
     def session_runtime(records, header)
       result = {
         "provider" => header["provider"],
@@ -756,8 +820,7 @@ module Kward
 
     def session_info(path)
       records = records_from_file(path)
-      header = records.find { |record| record["type"] == "session" }
-      return nil unless header && header["id"].to_s != ""
+      header = session_header(records, path)
 
       messages = restored_messages(records)
       name = session_name(records)