kward 0.68.0 → 0.69.0

data/lib/kward/compactor.rb

@@ -482,7 +482,7 @@ module Kward
           kept_messages: kept_messages,
           turn_prefix_messages: cut.turn_prefix_messages,
           split_turn: cut.split_turn,
-          tokens_before: @estimator.context_tokens(@conversation.messages),
+          tokens_before: @estimator.context_tokens(@conversation.context_messages),
           previous_summary: previous_entry ? compaction_summary(previous_entry) : nil,
           file_ops: file_ops,
           settings: @settings
@@ -866,7 +866,7 @@ module Kward
       context_window ||= @settings.context_window
       return nil unless context_window
 
-      context_tokens ||= Compaction::TokenEstimator.new.context_tokens(@conversation.messages)
+      context_tokens ||= Compaction::TokenEstimator.new.context_tokens(@conversation.context_messages)
       reserve_tokens = auto_compaction_reserve_tokens(context_window: context_window.to_i)
       return nil unless context_tokens.to_i > context_window.to_i - reserve_tokens
 

data/lib/kward/config_files.rb

@@ -77,6 +77,7 @@ module Kward
         "sessions" => {
           "auto_resume" => false
         },
+        "enforce_workspace_agents_file" => false,
         "tools" => {
           "workspace_guardrails" => true
         }
@@ -206,6 +207,12 @@ module Kward
       sessions["auto_resume"] == true
     end
 
+    # Returns whether workspace AGENTS.md contents should be injected directly
+    # instead of a compact read-when-relevant instruction.
+    def enforce_workspace_agents_file?(config = read_config)
+      config["enforce_workspace_agents_file"] == true
+    end
+
     # Returns the nested web-search config object, or an empty config when absent.
     def web_search_config(config = read_config)
       value = config["web_search"]
@@ -236,12 +243,25 @@ module Kward
       overlay_settings(config)
     end
 
-    # Reads global agent instructions from the config directory.
+    # Reads global principle instructions from the config directory.
+    #
+    # `PRINCIPLES.md` is preferred. `AGENTS.md` remains a backwards-compatible
+    # alias for existing installations.
     #
     # @return [String, nil] prompt text, or nil when absent/too large
     def agents_prompt
-      path = File.join(config_dir, "AGENTS.md")
-      read_prompt_file(path, "Kward prompt file")
+      path = config_principles_path
+      return read_prompt_file(path, "Kward principles file") if File.exist?(path)
+
+      read_prompt_file(config_agents_path, "Kward AGENTS.md alias")
+    end
+
+    def config_principles_path
+      File.join(config_dir, "PRINCIPLES.md")
+    end
+
+    def config_agents_path
+      File.join(config_dir, "AGENTS.md")
     end
 
     # Builds persona prompt text from default, workspace, model, reasoning,
@@ -299,22 +319,30 @@ module Kward
 
       characters = crew_characters(personas)
       entries = []
-
-      add_persona_entry(entries, "default", resolved_persona_text(personas["default"], characters: characters))
+      active_persona = { layer: "default", value: personas["default"], name: nil }
 
       workspaces = personas["workspaces"]
       if workspaces.is_a?(Hash)
         root = canonical_workspace_root(workspace_root)
         workspaces.each do |path, key|
           if canonical_workspace_root(path) == root
-            add_persona_entry(entries, "workspace", resolved_persona_text(key, characters: characters), name: path)
+            active_persona = { layer: "workspace", value: key, name: path }
             break
           end
         end
       end
 
       models = personas["models"]
-      add_persona_entry(entries, "model", resolved_persona_text(models[model.to_s], characters: characters), name: model.to_s) if models.is_a?(Hash) && !model.to_s.empty?
+      if models.is_a?(Hash) && !model.to_s.empty? && models.key?(model.to_s)
+        active_persona = { layer: "model", value: models[model.to_s], name: model.to_s }
+      end
+
+      add_persona_entry(
+        entries,
+        active_persona.fetch(:layer),
+        resolved_persona_text(active_persona.fetch(:value), characters: characters),
+        name: active_persona[:name]
+      )
 
       modifiers = personas["persona_modifiers"]
       if modifiers.is_a?(Hash)
@@ -336,10 +364,17 @@ module Kward
 
       entries
     end
+
+    def workspace_agents_path(workspace_root)
+      File.join(canonical_workspace_root(workspace_root), "AGENTS.md")
+    end
+
+    def workspace_agents_file?(workspace_root)
+      File.exist?(workspace_agents_path(workspace_root))
+    end
+
     def workspace_agents_prompt(workspace_root)
-      root = canonical_workspace_root(workspace_root)
-      path = File.join(root, "AGENTS.md")
-      read_prompt_file(path, "workspace AGENTS.md")
+      read_prompt_file(workspace_agents_path(workspace_root), "workspace AGENTS.md")
     end
 
     def read_prompt_file(path, label)

data/lib/kward/conversation.rb

@@ -21,8 +21,10 @@ module Kward
   class Conversation
     DEFAULT_SYSTEM_MESSAGE = Object.new.freeze
 
-    # @return [Array<Hash>] ordered transcript entries sent to providers and persisted in sessions
+    # @return [Array<Hash>] ordered durable transcript entries, excluding runtime system prompt state
     attr_reader :messages
+    # @return [Hash, nil] current system prompt included when building provider request context
+    attr_reader :system_message
     # @return [Set<String>] resolved paths read by file tools during the active context
     attr_reader :read_paths
     # @return [String] canonical workspace root used for prompts and file guardrails
@@ -45,12 +47,16 @@ module Kward
     attr_accessor :on_tool_execution
     # @return [Proc, nil] callback invoked when runtime metadata should be persisted
     attr_accessor :on_runtime_update
+    # @return [Proc, nil] callback invoked when the system prompt runtime state changes
+    attr_accessor :on_system_message_change
     # @return [String, nil] memory prompt context injected into refreshed system messages
     attr_accessor :memory_context
     # @return [Hash, nil] metadata for the last memory retrieval attached to the session
     attr_accessor :last_memory_retrieval
     # @return [PluginRegistry, nil] registry used to collect plugin prompt context
     attr_accessor :plugin_registry
+    # @return [String, nil] plugin prompt context used in the current system prompt
+    attr_reader :last_plugin_prompt_context
 
     def initialize(system_message: DEFAULT_SYSTEM_MESSAGE, messages: [], read_paths: [], on_append: nil, on_compact: nil, on_tool_execution: nil, on_runtime_update: nil, workspace_root: Dir.pwd, compaction_system_message: DEFAULT_SYSTEM_MESSAGE, provider: nil, model: nil, reasoning_effort: nil, memory_context: nil, session_memories: [], last_memory_retrieval: nil, plugin_registry: nil)
       @workspace_root = ConfigFiles.canonical_workspace_root(workspace_root)
@@ -59,10 +65,17 @@ module Kward
       @reasoning_effort = reasoning_effort
       @plugin_registry = plugin_registry
       @messages = []
+      restored_system_message, transcript_messages = split_system_message(messages)
       if system_message.equal?(DEFAULT_SYSTEM_MESSAGE)
-        system_message = messages.any? { |message| MessageAccess.role(message) == "system" } ? nil : Prompts.system_message(workspace_root: @workspace_root, model: @model, reasoning_effort: @reasoning_effort, memory_context: memory_context, plugin_context: plugin_prompt_context)
+        if restored_system_message
+          system_message = restored_system_message
+        else
+          @last_plugin_prompt_context = plugin_prompt_context
+          system_message = Prompts.system_message(workspace_root: @workspace_root, model: @model, reasoning_effort: @reasoning_effort, memory_context: memory_context, plugin_context: @last_plugin_prompt_context)
+        end
       end
-      @system_message_enabled = !!(system_message || messages.find { |message| MessageAccess.role(message) == "system" })
+      @system_message = system_message
+      @system_message_enabled = !@system_message.nil?
       if compaction_system_message.equal?(DEFAULT_SYSTEM_MESSAGE)
         compaction_system_message = @system_message_enabled ? Prompts.system_message(workspace_root: @workspace_root, include_workspace_personality: false, model: @model, reasoning_effort: @reasoning_effort) : nil
       end
@@ -72,13 +85,13 @@ module Kward
       @memory_context = memory_context
       @session_memories = Array(session_memories)
       @last_memory_retrieval = last_memory_retrieval
-      @messages << system_message unless system_message.nil?
-      @messages.concat(messages)
+      @messages.concat(transcript_messages)
       @read_paths = Set.new(read_paths)
       @on_append = on_append
       @on_compact = on_compact
       @on_tool_execution = on_tool_execution
       @on_runtime_update = on_runtime_update
+      @on_system_message_change = nil
     end
 
     # Appends a user message and normalizes image attachment syntax.
@@ -110,6 +123,11 @@ module Kward
       @on_tool_execution&.call(tool_call, content)
     end
 
+    # @return [Array<Hash>] provider request context: current system prompt plus durable transcript
+    def context_messages
+      @system_message ? [@system_message] + @messages : @messages.dup
+    end
+
     # Rebuilds the system message from current config, memory, plugins, and
     # workspace AGENTS.md state.
     #
@@ -119,9 +137,10 @@ module Kward
     def refresh_system_message!
       return nil unless @system_message_enabled
 
-      replacement = Prompts.system_message(workspace_root: @workspace_root, model: @model, reasoning_effort: @reasoning_effort, memory_context: @memory_context, plugin_context: plugin_prompt_context)
-      index = @messages.index { |message| MessageAccess.role(message) == "system" }
-      index ? @messages[index] = replacement : @messages.unshift(replacement)
+      @last_plugin_prompt_context = plugin_prompt_context
+      replacement = Prompts.system_message(workspace_root: @workspace_root, model: @model, reasoning_effort: @reasoning_effort, memory_context: @memory_context, plugin_context: @last_plugin_prompt_context)
+      @system_message = replacement
+      @on_system_message_change&.call(replacement)
       @compaction_system_message = Prompts.system_message(workspace_root: @workspace_root, include_workspace_personality: false, model: @model, reasoning_effort: @reasoning_effort)
       @workspace_agents_mtime = workspace_agents_mtime
       replacement
@@ -172,7 +191,7 @@ module Kward
         message[:from_hook] = from_hook
         message[:details] = details || {}
       end
-      @messages = @messages.select { |item| MessageAccess.role(item) == "system" }
+      @messages = []
       @messages << message
       @messages.concat(Array(keep_messages))
       @read_paths.clear
@@ -197,6 +216,19 @@ module Kward
 
     private
 
+    def split_system_message(messages)
+      system_message = nil
+      transcript_messages = []
+      Array(messages).each do |message|
+        if MessageAccess.role(message) == "system" && system_message.nil?
+          system_message = message
+        elsif MessageAccess.role(message) != "system"
+          transcript_messages << message
+        end
+      end
+      [system_message, transcript_messages]
+    end
+
     def workspace_agents_mtime
       path = File.join(@workspace_root, "AGENTS.md")
       File.exist?(path) ? File.mtime(path) : nil

data/lib/kward/memory/manager.rb

@@ -23,6 +23,7 @@ module Kward
       DEFAULT_SOFT_TTL_DAYS = 60
       DEFAULT_SOFT_CONFIDENCE = 0.65
       EMOTIONAL_PATTERN = /\b(love|loves|romantic|intimate|dependency|depend on me|need me|flirty|crush)\b/i
+      MEMORY_DUPLICATE_STOPWORDS = Set.new(%w[a an and as at for in of on or that the this to with])
 
       # Details for the most recent retrieval, used by `/memory why`.
       attr_reader :last_retrieval
@@ -148,10 +149,20 @@ module Kward
       # @param ttl_days [Integer, nil] time-to-live in days
       # @return [Hash] stored memory record
       def add_soft(text, scope: "global", tags: [], confidence: DEFAULT_SOFT_CONFIDENCE, ttl_days: DEFAULT_SOFT_TTL_DAYS, source: "manual")
+        normalized_scope = clean_scope(scope)
+        normalized_text = clean_text(normalize_memory_text(text))
+        raise ArgumentError, "Memory text cannot be empty" if normalized_text.empty?
+        raise ArgumentError, "Refusing to persist emotional or dependency-forming memory automatically" if source == "inferred" && unsafe_soft_text?(normalized_text)
+
+        existing = soft_memories.find do |item|
+          item["scope"] == normalized_scope && duplicate_memory_text?(normalized_text, [item["text"]])
+        end
+        return existing if existing
+
         record = {
           "id" => next_id("soft", soft_memories(include_inactive: true).map { |item| item["id"] }),
-          "text" => clean_text(normalize_memory_text(text)),
-          "scope" => clean_scope(scope),
+          "text" => normalized_text,
+          "scope" => normalized_scope,
           "tags" => clean_tags(tags),
           "confidence" => [[confidence.to_f, 0.0].max, 1.0].min,
           "hits" => 0,
@@ -162,8 +173,6 @@ module Kward
           "source" => source,
           "status" => "active"
         }
-        raise ArgumentError, "Memory text cannot be empty" if record["text"].empty?
-        raise ArgumentError, "Refusing to persist emotional or dependency-forming memory automatically" if source == "inferred" && unsafe_soft_text?(record["text"])
 
         append_soft(record)
         append_event("add", event_ref(record, layer: "soft"))
@@ -232,16 +241,20 @@ module Kward
       end
 
       def list(include_inactive: false)
-        { "core" => core_memories, "soft" => soft_memories(include_inactive: include_inactive) }
+        soft = soft_memories(include_inactive: include_inactive)
+        soft = deduplicate_soft_records(soft) unless include_inactive
+        { "core" => core_memories, "soft" => soft }
       end
 
       def hierarchy(workspace_root: Dir.pwd, include_inactive: false)
         workspace = workspace_scope(workspace_root)
         core = core_memories
+        soft = soft_memories(include_inactive: include_inactive)
+        soft = deduplicate_soft_records(soft) unless include_inactive
         {
           "global_core" => core.select { |item| item["scope"] == "global" },
           "workspace_core" => core.select { |item| item["scope"] == workspace },
-          "workspace_soft" => soft_memories(include_inactive: include_inactive).select { |item| item["scope"] == workspace }
+          "workspace_soft" => soft.select { |item| item["scope"] == workspace }
         }
       end
 
@@ -271,8 +284,7 @@ module Kward
         core_reasons = core.map { |item| reason_for(item, layer: "core", score: 1.0, reasons: ["scope match", "core memories are preferred"]) }
 
         soft_records_all = soft_memories(include_inactive: true)
-        soft_scored = soft_records_all.filter_map do |item|
-          next unless item["status"] == "active"
+        soft_scored = deduplicate_soft_records(soft_records_all.select { |item| item["status"] == "active" }).filter_map do |item|
           next unless item["scope"] == workspace
           next if expired?(item)
 
@@ -354,14 +366,118 @@ module Kward
       def infer_soft_from_text(text, workspace_root: Dir.pwd, client: nil, existing_texts: [])
         candidates = heuristic_candidates(text)
         existing_set = Set.new(existing_texts.map { |t| normalize_for_comparison(t) })
+        scope = workspace_scope(workspace_root)
+        workspace_scopes = [scope, clean_scope("workspace:#{workspace_root}")].uniq
+        workspace_soft_texts = soft_memories.select { |memory| workspace_scopes.include?(memory["scope"]) }.map { |memory| memory["text"] }
         candidates.filter_map do |candidate|
-          summarized = summarize_text(candidate, client: client)
+          summarized = normalize_inferred_memory_text(summarize_text(candidate, client: client), source_text: candidate)
           normalized = normalize_for_comparison(summarized)
           # Skip if this text already exists in provided list or existing soft memories
           next if existing_set.include?(normalized)
-          next if soft_memories.any? { |m| normalize_for_comparison(m["text"]) == normalized }
+          next if duplicate_memory_text?(summarized, existing_texts)
+          next if duplicate_memory_text?(summarized, workspace_soft_texts)
+
+          record = add_soft(summarized, scope: scope, tags: ["workflow"], confidence: 0.55, source: "inferred")
+          workspace_soft_texts << record["text"]
+          record
+        end
+      end
+
+      def normalize_inferred_memory_text(text, source_text: nil)
+        normalized = normalize_memory_text(text)
+        source = source_text.to_s
+        first_person_source = source.match?(/\b(?:i|we|my|our)\b/i)
+
+        if first_person_source
+          normalized = normalized.sub(/\AThe\s+\w+\s+(prefers|likes|uses|usually|always|wants|believes|thinks|avoids)\b/i) do
+            "The user #{Regexp.last_match(1).downcase}"
+          end
+          normalized = normalized.sub(/\AI\s+(?:(usually|always)\s+)?(prefer|like|use|want|believe|think|avoid)\b/i) do
+            adverb = Regexp.last_match(1)
+            verb = third_person_verb(Regexp.last_match(2))
+            ["The user", adverb&.downcase, verb].compact.join(" ")
+          end
+          normalized = normalized.sub(/\AWe\s+(?:(usually|always)\s+)?(prefer|like|use|want|believe|think|avoid)\b/i) do
+            adverb = Regexp.last_match(1)
+            verb = third_person_verb(Regexp.last_match(2))
+            ["The user", adverb&.downcase, verb].compact.join(" ")
+          end
+          normalized = normalized.sub(/\AMy\s+/i, "The user's ")
+          normalized = normalized.sub(/\AOur\s+/i, "The user's ")
+        end
+
+        clean_text(normalized)
+      end
+
+      def third_person_verb(verb)
+        word = verb.to_s.downcase
+        return word if ["usually", "always"].include?(word)
+        return "uses" if word == "use"
+
+        word.end_with?("s") ? word : "#{word}s"
+      end
+
+      def duplicate_memory_text?(text, existing_texts)
+        candidate = memory_duplicate_key(text)
+        candidate_tokens = memory_duplicate_tokens(text)
+        Array(existing_texts).any? do |existing|
+          existing_key = memory_duplicate_key(existing)
+          next true if existing_key == candidate
+
+          existing_tokens = memory_duplicate_tokens(existing)
+          next false if candidate_tokens.empty? || existing_tokens.empty?
+
+          overlap = (candidate_tokens & existing_tokens).length
+          union = (candidate_tokens | existing_tokens).length
+          union.positive? && overlap.to_f / union >= 0.8
+        end
+      end
+
+      def memory_duplicate_key(text)
+        normalized = normalize_for_comparison(text).downcase
+        normalized = normalized.sub(/\Ai\s+(?:(usually|always)\s+)?(prefer|like|use|want|believe|think|avoid)\b/i) do
+          ["the user", Regexp.last_match(1)&.downcase, third_person_verb(Regexp.last_match(2))].compact.join(" ")
+        end
+        normalized = normalized.sub(/\Awe\s+(?:(usually|always)\s+)?(prefer|like|use|want|believe|think|avoid)\b/i) do
+          ["the user", Regexp.last_match(1)&.downcase, third_person_verb(Regexp.last_match(2))].compact.join(" ")
+        end
+        normalized = normalized.sub(/\Amy\s+/i, "the user's ")
+        normalized = normalized.sub(/\Aour\s+/i, "the user's ")
+        normalized.tr("“”‘’", "\"\"''")
+      end
+
+      def memory_duplicate_tokens(text)
+        memory_duplicate_key(text).scan(/[a-z0-9_\-']{3,}/).filter_map do |term|
+          token = memory_duplicate_token(term)
+          token unless MEMORY_DUPLICATE_STOPWORDS.include?(token)
+        end.uniq
+      end
+
+      def memory_duplicate_token(term)
+        case term
+        when "uses", "using"
+          "use"
+        when "prefers", "preferring"
+          "prefer"
+        when "avoids", "avoiding"
+          "avoid"
+        else
+          term.sub(/\A(.{4,})s\z/, '\\1')
+        end
+      end
+
+      def deduplicate_soft_records(records)
+        seen = []
+        records.each_with_object([]) do |record, deduplicated|
+          scope = record["scope"]
+          text = record["text"]
+          duplicate = seen.any? do |seen_record|
+            seen_record["scope"] == scope && duplicate_memory_text?(text, [seen_record["text"]])
+          end
+          next if duplicate
 
-          add_soft(summarized, scope: workspace_scope(workspace_root), tags: ["workflow"], confidence: 0.55, source: "inferred")
+          seen << record
+          deduplicated << record
         end
       end
 
@@ -404,16 +520,17 @@ module Kward
             You are a memory text reformulation assistant. Your task is to transform user-generated text into proper third-person descriptive memory statements.
 
             Rules:
-            - Convert first-person statements ("I like", "we prefer") to third-person ("The captain likes", "The user prefers")
+            - Convert first-person statements ("I like", "we prefer") to third-person ("The user likes", "The user prefers")
             - Remove conversational filler, preambles, and action descriptions
             - Keep only the factual preference or fact
-            - Use "The captain" or "The user" as the subject for personal preferences
+            - Always use "The user" as the subject for personal preferences
+            - Do not use persona-specific names, titles, roles, or nicknames
             - Preserve workflow-related technical preferences as-is
             - Keep the text concise (under 100 characters)
             - If the text is already a good memory statement, return it unchanged
 
             Examples:
-            - "I like to eat the most important meal today: steak" → "The captain likes eating steak"
+            - "I like to eat the most important meal today: steak" → "The user likes eating steak"
             - "We should prefer TDD for this project" → "Prefer TDD for this project"
             - "Remember that the user prefers minitest" → "The user prefers minitest"
             - "But first we need to remember that we are using TDD" → "Use TDD"

data/lib/kward/message_access.rb

@@ -59,5 +59,11 @@ module Kward
       calls = value(message, :tool_calls) || value(message, :toolCalls)
       calls.is_a?(Array) ? calls : []
     end
+
+    # @return [Array<Hash>] provider-native Responses output items, or an empty array
+    def response_items(message)
+      items = value(message, :response_items) || value(message, :responseItems)
+      items.is_a?(Array) ? items : []
+    end
   end
 end

data/lib/kward/model/context_usage.rb

@@ -14,9 +14,8 @@ module Kward
     def call(provider:, model:, context_window:, context_parts:)
       return nil unless OPENAI_CONTEXT_PROVIDERS.include?(provider.to_s)
       return nil unless context_window
-      return nil if contains_image?(context_parts)
 
-      parts = stringify_keys(context_parts || {})
+      parts = redact_image_data(stringify_keys(context_parts || {}))
       return nil unless contains_session_content?(parts)
 
       payload = prompt_payload(parts)
@@ -58,21 +57,23 @@ module Kward
       false
     end
 
-    def contains_image?(value)
+    def redact_image_data(value)
       case value
       when Hash
-        type = value[:type] || value["type"]
-        return true if ["image", "input_image", "image_url"].include?(type.to_s)
-        return true if value.key?(:image_url) || value.key?("image_url")
-
-        value.any? { |_key, item| contains_image?(item) }
+        value.each_with_object({}) do |(key, item), result|
+          result[key] = image_data_key?(key) ? "[image omitted from token estimate]" : redact_image_data(item)
+        end
       when Array
-        value.any? { |item| contains_image?(item) }
+        value.map { |item| redact_image_data(item) }
       else
-        false
+        value
       end
     end
 
+    def image_data_key?(key)
+      ["data", "image_url"].include?(key.to_s)
+    end
+
     def stringify_keys(value)
       return value unless value.is_a?(Hash)
 

data/lib/kward/model/model_info.rb

@@ -71,6 +71,23 @@ module Kward
       /(?:\A|\/)gpt-5\.3-codex-spark\z/
     ].freeze
 
+    CODEX_CONTEXT_WINDOWS = [
+      [/\Agpt-5\.5/, 400_000],
+      [/\Agpt-5\.4-mini/, 400_000],
+      [/\Agpt-5\.4/, 1_050_000],
+      [/\Agpt-5-mini/, 400_000],
+      [/\Agpt-5-codex/, 400_000],
+      [/\Agpt-5\.3-codex-spark/, 128_000],
+      [/\Agpt-5\.3-codex/, 400_000],
+      [/\Agpt-5\.2-codex/, 400_000],
+      [/\Agpt-5/, 400_000],
+      [/\Agpt-4\.1/, 1_047_576],
+      [/\Agpt-4o/, 128_000],
+      [/\Ao3/, 200_000],
+      [/\Ao4/, 200_000],
+      [/\Agpt-4/, 128_000],
+      [/\Agpt-3\.5-turbo/, 16_385]
+    ].freeze
     OPENAI_CONTEXT_WINDOWS = [
       [/\Agpt-5\.5/, 1_050_000],
       [/\Agpt-5\.4-mini/, 400_000],
@@ -214,7 +231,7 @@ module Kward
     def context_window(provider, id)
       case provider
       when "Codex"
-        pattern_context_window(OPENAI_CONTEXT_WINDOWS, id)
+        pattern_context_window(CODEX_CONTEXT_WINDOWS, id)
       when "OpenRouter"
         openrouter_context_window(id)
       when "Copilot"

data/lib/kward/model/payloads.rb

@@ -239,6 +239,7 @@ module Kward
         "edit_file" => "Edit",
         "run_shell_command" => "Bash",
         "web_search" => "WebSearch",
+        "fetch_content" => "WebFetch",
         "ask_user_question" => "AskUserQuestion"
       }[name.to_s]
       return mapped if mapped
@@ -291,16 +292,21 @@ module Kward
             output: plain_content(content).to_s
           }
         when "assistant"
-          content = plain_content(content)
-          input << codex_message("assistant", content.to_s) unless content.to_s.empty?
-          MessageAccess.tool_calls(message).each do |tool_call|
-            function = tool_call[:function] || tool_call["function"] || {}
-            input << {
-              type: "function_call",
-              call_id: tool_call[:id] || tool_call["id"] || function[:name] || function["name"] || "tool-call",
-              name: function[:name] || function["name"],
-              arguments: function[:arguments] || function["arguments"] || "{}"
-            }
+          response_items = codex_replay_response_items(message)
+          if response_items.empty?
+            content = plain_content(content)
+            input << codex_message("assistant", content.to_s) unless content.to_s.empty?
+            MessageAccess.tool_calls(message).each do |tool_call|
+              function = tool_call[:function] || tool_call["function"] || {}
+              input << {
+                type: "function_call",
+                call_id: tool_call[:id] || tool_call["id"] || function[:name] || function["name"] || "tool-call",
+                name: function[:name] || function["name"],
+                arguments: function[:arguments] || function["arguments"] || "{}"
+              }
+            end
+          else
+            input.concat(response_items)
           end
         when "compactionSummary"
           summary = MessageAccess.summary(message) || content
@@ -332,6 +338,79 @@ module Kward
       { type: "message", role: role, content: [{ type: type, text: text }] }
     end
 
+    def codex_replay_response_items(message)
+      items = MessageAccess.response_items(message)
+      return [] if items.empty?
+
+      items.filter_map { |item| codex_replay_response_item(item) }
+    end
+
+    def codex_replay_response_item(item)
+      return nil unless item.is_a?(Hash)
+
+      case item[:type] || item["type"]
+      when "reasoning"
+        codex_replay_reasoning_item(item)
+      when "message"
+        codex_replay_message_item(item)
+      when "function_call", "custom_tool_call"
+        codex_replay_tool_call_item(item)
+      end
+    end
+
+    def codex_replay_reasoning_item(item)
+      result = { type: "reasoning" }
+      summary = item[:summary] || item["summary"]
+      content = item[:content] || item["content"]
+      encrypted_content = item[:encrypted_content] || item["encrypted_content"]
+      result[:summary] = summary if summary.is_a?(Array)
+      result[:content] = content if content.is_a?(Array)
+      result[:encrypted_content] = encrypted_content if encrypted_content
+      result
+    end
+
+    def codex_replay_message_item(item)
+      content = item[:content] || item["content"]
+      return nil unless content.is_a?(Array)
+
+      result = { type: "message", role: item[:role] || item["role"] || "assistant", content: codex_replay_message_content(content) }
+      phase = item[:phase] || item["phase"]
+      result[:phase] = phase if phase
+      result
+    end
+
+    def codex_replay_message_content(content)
+      content.filter_map do |part|
+        next unless part.is_a?(Hash)
+
+        type = part[:type] || part["type"]
+        next unless ["output_text", "text", "refusal"].include?(type)
+
+        replay_part = { type: type }
+        text = part[:text] || part["text"]
+        refusal = part[:refusal] || part["refusal"]
+        replay_part[:text] = text.to_s if text || type != "refusal"
+        replay_part[:refusal] = refusal.to_s if refusal
+        annotations = part[:annotations] || part["annotations"]
+        replay_part[:annotations] = annotations if annotations.is_a?(Array)
+        replay_part
+      end
+    end
+
+    def codex_replay_tool_call_item(item)
+      type = item[:type] || item["type"]
+      result = { type: type }
+      call_id = item[:call_id] || item["call_id"]
+      name = item[:name] || item["name"]
+      arguments = item[:arguments] || item["arguments"]
+      input = item[:input] || item["input"]
+      result[:call_id] = call_id if call_id
+      result[:name] = name if name
+      result[:arguments] = arguments if arguments
+      result[:input] = input if input
+      result
+    end
+
     def plain_content(content)
       return content unless content.is_a?(Array)