kward 0.81.0 → 0.83.0

data/lib/kward/cli.rb

@@ -10,12 +10,19 @@ require_relative "compactor"
 require_relative "config_files"
 require_relative "clipboard"
 require_relative "cancellation"
+require_relative "editor_prompt"
+require_relative "editor_prompt_session"
+require_relative "shell_prompt"
+require_relative "shell_prompt_session"
 require_relative "cli_transcript_formatter"
 require_relative "model/context_usage"
 require_relative "events"
 require_relative "export_path"
 require_relative "ekwsh"
+require_relative "persistent_shell_session"
 require_relative "interactive_pty_runner"
+require_relative "adaptive_pty_output_sink"
+require_relative "pty_transcript_normalizer"
 require_relative "auth/anthropic_oauth"
 require_relative "auth/api_key_store"
 require_relative "auth/github_oauth"
@@ -475,6 +482,11 @@ module Kward
           run_ekwsh_loop(active_tab.shell, tab: active_tab, history: build_ekwsh_history(active_tab.agent))
         end
         input = @pending_inputs.shift || (active_tab ? poll_active_tab_input : @prompt.ask("You>"))
+        if input.is_a?(Hash) && input[:editor_prompt]
+          pending_inputs = run_editor_prompt_turn(input[:editor_prompt], active_tab&.agent || agent)
+          pending_inputs.reverse_each { |pending_input| @pending_inputs.unshift(pending_input) }
+          next
+        end
         if input.is_a?(Hash) && input[:tab_action]
           tab_result = handle_tab_action(input, session_store)
           break if tab_result == PromptInterface::EXIT_INPUT

data/lib/kward/compaction/token_estimator.rb

@@ -31,13 +31,15 @@ module Kward
         parts = [role]
         if role.to_s == "compactionSummary"
           parts << value(message, :summary)
-        else
+        elsif response_items(message).empty?
           parts << content_text(value(message, :content))
-        end
-        parts << value(message, :reasoning_summary)
-        tool_calls(message).each do |tool_call|
-          parts << tool_call_name(tool_call)
-          parts << tool_call_arguments(tool_call)
+          parts << value(message, :reasoning_summary)
+          tool_calls(message).each do |tool_call|
+            parts << tool_call_name(tool_call)
+            parts << tool_call_arguments(tool_call)
+          end
+        else
+          parts << JSON.generate(response_items(message))
         end
         parts << value(message, :tool_call_id)
         parts << value(message, :name)
@@ -65,6 +67,10 @@ module Kward
         MessageAccess.tool_calls(message)
       end
 
+      def response_items(message)
+        MessageAccess.response_items(message)
+      end
+
       def tool_call_name(tool_call)
         ToolCall.name(tool_call)
       end

data/lib/kward/config_files.rb

@@ -136,6 +136,7 @@ module Kward
         },
         "editor" => {
           "mode" => "modern",
+          "agent" => {},
           "auto_indent" => true,
           "auto_close_pairs" => true,
           "soft_wrap" => true,
@@ -482,6 +483,22 @@ module Kward
       EditorMode.normalize(editor["mode"])
     end
 
+    # Returns the optional model override for editor-agent turns.
+    def editor_agent_model(config = read_config)
+      editor = config["editor"].is_a?(Hash) ? config["editor"] : {}
+      agent = editor["agent"].is_a?(Hash) ? editor["agent"] : {}
+      value = agent["model"].to_s.strip
+      value.empty? ? nil : value
+    end
+
+    # Returns the optional reasoning-effort override for editor-agent turns.
+    def editor_agent_reasoning_effort(config = read_config)
+      editor = config["editor"].is_a?(Hash) ? config["editor"] : {}
+      agent = editor["agent"].is_a?(Hash) ? editor["agent"] : {}
+      value = agent["reasoning_effort"].to_s.strip
+      value.empty? ? nil : value
+    end
+
     # Returns whether the built-in TUI editor should auto-indent new lines.
     def editor_auto_indent?(config = read_config)
       editor = config["editor"].is_a?(Hash) ? config["editor"] : {}

data/lib/kward/editor_prompt.rb

@@ -0,0 +1,46 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Builds the model-facing request for an in-memory editor prompt.
+  module EditorPrompt
+    module_function
+
+    def system_message
+      {
+        role: "system",
+        content: <<~PROMPT.strip
+          You are Kward's in-memory editor assistant.
+
+          Act only on the user's explicit request about the active editor buffer. Do not volunteer changes, explanations, or unrelated work. For an actionable edit request, call replace_editor_buffer with the complete replacement buffer. For a request that is only a question or needs clarification, answer briefly without changing the buffer. Never write files to disk and never claim that the buffer was saved.
+        PROMPT
+      }
+    end
+
+    def input(instruction, context)
+      document = context[:display_path].to_s
+      language = context[:language].to_s
+      language = "text" if language.empty?
+      content = context[:content].to_s
+
+      <<~PROMPT
+        You are operating inside an interactive editor.
+
+        The user requested:
+        #{instruction}
+
+        Active document: #{document.empty? ? "(untitled)" : document}
+        Language: #{language}
+        Cursor: line #{context.dig(:cursor, 0).to_i + 1}, column #{context.dig(:cursor, 1).to_i + 1}
+        Selected text: #{context[:selection].to_s.empty? ? "(none)" : "present; full-buffer replacement is required"}
+
+        Current buffer:
+        <editor_buffer>
+        #{content}
+        </editor_buffer>
+
+        Satisfy the user's request by calling replace_editor_buffer with the complete desired buffer contents.
+        The operation changes only the in-memory editor buffer. Do not write files to disk.
+        If the request is ambiguous, explain the ambiguity instead of changing the buffer.
+      PROMPT
+    end
+  end
+end

data/lib/kward/editor_prompt_session.rb

@@ -0,0 +1,28 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Transactional draft used while an agent works on an active editor buffer.
+  #
+  # The live terminal editor remains owned by PromptInterface. Agent tool calls
+  # update this draft and the caller commits it only after a successful turn.
+  class EditorPromptSession
+    attr_reader :context, :content
+
+    def initialize(context)
+      @context = context.dup
+      @initial_content = @context.fetch(:content).to_s.dup
+      @content = @initial_content.dup
+    end
+
+    def replace(content)
+      @content = content.to_s
+    end
+
+    def changed?
+      @content != @initial_content
+    end
+
+    def initial_content
+      @initial_content.dup
+    end
+  end
+end

data/lib/kward/ekwsh.rb

@@ -18,17 +18,16 @@ module Kward
     DEFAULT_TIMEOUT_SECONDS = 300
     DEFAULT_MAX_OUTPUT_BYTES = 1_048_576
     DEFAULT_HISTORY_LIMIT = 1_000
+    CONTEXT_OUTPUT_BYTES = 32_000
 
-    attr_reader :cwd
+    attr_reader :cwd, :last_command, :timeout_seconds
 
     def command_shell
       @shell
     end
 
     def child_env(interactive: false)
-      env = @env.dup
-      env.delete("GIT_PAGER") if interactive && @defaulted_git_pager
-      env
+      @env.dup
     end
 
     def initialize(cwd: Dir.pwd, env: ENV.to_h, shell: DEFAULT_SHELL, configured_env: {}, aliases: {}, timeout_seconds: DEFAULT_TIMEOUT_SECONDS, max_output_bytes: DEFAULT_MAX_OUTPUT_BYTES)
@@ -43,6 +42,8 @@ module Kward
       @shell = shell.to_s.empty? ? DEFAULT_SHELL : shell.to_s
       @timeout_seconds = timeout_seconds.to_i.positive? ? timeout_seconds.to_i : DEFAULT_TIMEOUT_SECONDS
       @max_output_bytes = max_output_bytes.to_i.positive? ? max_output_bytes.to_i : DEFAULT_MAX_OUTPUT_BYTES
+      @last_command = nil
+      @last_result = nil
     end
 
     def prompt_label
@@ -53,7 +54,45 @@ module Kward
       command = input.to_s.strip
       return Result.new(output: "", exit_status: 0) if command.empty?
 
-      run_expanded_command(command, cancellation: cancellation, &block)
+      result = run_expanded_command(command, cancellation: cancellation, &block)
+      remember_result(command, result)
+      result
+    end
+
+    # Runs a command for the shell assistant without handing it the terminal.
+    # Built-ins still execute in this Ekwsh instance so their state persists.
+    def run_for_agent(input, timeout_seconds: nil, cancellation: nil)
+      command = input.to_s.strip
+      return run(command, cancellation: cancellation) if command.empty?
+
+      result = run(command, cancellation: cancellation)
+      return result unless result.interactive_command
+
+      result = execute(
+        result.interactive_command,
+        display_command: command,
+        timeout_seconds: timeout_seconds,
+        cancellation: cancellation
+      )
+      remember_result(command, result)
+      result
+    end
+
+    # Records the output of an interactive command after terminal handoff.
+    def record_interactive_result(output:, exit_status:)
+      return unless @last_command
+
+      @last_result = Result.new(output: ANSI.sanitize_transcript(output.to_s), exit_status: exit_status)
+    end
+
+    # Returns bounded shell state for an explicit shell-agent prompt.
+    def context_snapshot(max_output_bytes: CONTEXT_OUTPUT_BYTES)
+      {
+        cwd: @cwd,
+        last_command: @last_command,
+        exit_status: @last_result&.exit_status,
+        last_output: context_output(@last_result&.output, max_output_bytes)
+      }
     end
 
     def complete(input, cursor)
@@ -112,8 +151,6 @@ module Kward
     def configure_color_environment
       @env["CLICOLOR"] ||= "1"
       @env["COLORTERM"] ||= "truecolor"
-      @defaulted_git_pager = !@env.key?("GIT_PAGER")
-      @env["GIT_PAGER"] ||= "cat"
       @env["TERM"] = "xterm-256color" if @env["TERM"].to_s.empty? || @env["TERM"] == "dumb"
     end
 
@@ -522,12 +559,13 @@ module Kward
       key.to_s.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/)
     end
 
-    def execute(command, display_command: command, cancellation: nil)
+    def execute(command, display_command: command, timeout_seconds: nil, cancellation: nil)
       output = command_echo(display_command)
       streamed = block_given?
       yield output.dup if streamed
+      timeout = effective_timeout(timeout_seconds)
       result = external_command_runner.new(
-        timeout_seconds: @timeout_seconds,
+        timeout_seconds: timeout,
         max_output_bytes: @max_output_bytes,
         terminate_on_output_limit: true
       ).run(@shell, "-c", command, env: @env, cwd: @cwd, cancellation: cancellation) do |_stream, chunk|
@@ -537,7 +575,7 @@ module Kward
       end
       append_output_newline(output) { |text| yield text if streamed }
       exit_status = result.timed_out || result.truncated ? 1 : (result.exit_status || 1)
-      append_streamed(output, "ekwsh: command timed out after #{@timeout_seconds} seconds\n", streamed) { |text| yield text } if result.timed_out
+      append_streamed(output, "ekwsh: command timed out after #{timeout} seconds\n", streamed) { |text| yield text } if result.timed_out
       append_streamed(output, "ekwsh: output exceeded #{@max_output_bytes} bytes; command terminated\n", streamed) { |text| yield text } if result.truncated
       append_streamed(output, "Exit status: #{exit_status}\n", streamed) { |text| yield text } unless exit_status.zero?
       Result.new(output: output, exit_status: exit_status, streamed: streamed)
@@ -549,6 +587,28 @@ module Kward
       Result.new(output: "#{command_echo(display_command)}ekwsh: #{e.message}\n", exit_status: 127)
     end
 
+    def effective_timeout(timeout_seconds)
+      timeout = timeout_seconds.to_i
+      timeout.positive? ? timeout : @timeout_seconds
+    end
+
+    def remember_result(command, result)
+      @last_command = command.to_s
+      @last_result = result
+    end
+
+    def context_output(output, max_output_bytes)
+      text = ANSI.sanitize_transcript(output.to_s)
+      limit = max_output_bytes.to_i
+      return text if limit <= 0 || text.bytesize <= limit
+
+      prefix = "[Earlier output omitted; showing the end of the command output.]\n"
+      tail_limit = [limit - prefix.bytesize, 0].max
+      tail = text.byteslice(-tail_limit, tail_limit).to_s if tail_limit.positive?
+      value = "#{prefix}#{tail}"
+      ANSI.normalize_transcript_encoding(value.byteslice(-limit, limit).to_s)
+    end
+
     def external_command_runner
       defined?(LocalPtyCommandRunner) ? LocalPtyCommandRunner : LocalCommandRunner
     end

data/lib/kward/image_attachments.rb

@@ -1,8 +1,10 @@
 require "base64"
 require "cgi/escape"
+require "open3"
 require "shellwords"
 require "tmpdir"
 require "uri"
+require_relative "terminal_image_support"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -291,6 +293,71 @@ module Kward
       MIME_TYPES.key?(File.extname(path.to_s).downcase)
     end
 
+    def image_part_from_path(path)
+      expanded_path = File.expand_path(path.to_s)
+      return nil unless File.file?(expanded_path)
+
+      media_type = mime_type(expanded_path)
+      return nil unless media_type
+
+      size = File.size(expanded_path)
+      return nil if size > MAX_IMAGE_BYTES
+
+      {
+        type: "image",
+        media_type: media_type,
+        data: Base64.strict_encode64(File.binread(expanded_path)),
+        path: expanded_path,
+        size_bytes: size
+      }
+    rescue SystemCallError
+      nil
+    end
+
+    def terminal_image_part(part, protocol)
+      return part unless protocol == :kitty
+      return part if image_media_type(part) == "image/png"
+
+      convert_image_part_to_png(part)
+    end
+
+    def png_dimensions(part)
+      encoded = part[:data] || part["data"]
+      header = Base64.strict_decode64(encoded.to_s[0, 32])
+      return nil unless header.start_with?("\x89PNG\r\n\x1A\n".b)
+      return nil unless header.byteslice(12, 4) == "IHDR"
+
+      width, height = header.byteslice(16, 8).unpack("NN")
+      return nil unless width.positive? && height.positive?
+
+      [width, height]
+    rescue ArgumentError, NoMethodError
+      nil
+    end
+
+    def convert_image_part_to_png(part)
+      path = part[:path] || part["path"]
+      return nil unless path && File.file?(path)
+
+      stdout, _stderr, status = Open3.capture3(
+        "magick",
+        "-limit", "memory", "128MiB",
+        "-limit", "map", "256MiB",
+        "#{path}[0]",
+        "png:-"
+      )
+      return nil unless status.success?
+      return nil if stdout.empty? || stdout.bytesize > MAX_IMAGE_BYTES
+
+      part.merge(
+        media_type: "image/png",
+        data: Base64.strict_encode64(stdout),
+        size_bytes: stdout.bytesize
+      )
+    rescue SystemCallError
+      nil
+    end
+
     def mime_type(path)
       MIME_TYPES[File.extname(path.to_s).downcase]
     end
@@ -300,36 +367,52 @@ module Kward
       "data:#{media_type};base64,#{part[:data] || part["data"]}"
     end
 
-    def terminal_image_sequence(part, width: DEFAULT_TERMINAL_IMAGE_WIDTH, env: ENV)
+    def terminal_image_sequence(part, width: DEFAULT_TERMINAL_IMAGE_WIDTH, height: nil, protocol: nil, image_id: nil, move_cursor: true, env: ENV)
       data = part[:data] || part["data"]
       return nil if data.to_s.empty?
 
+      protocol ||= terminal_image_protocol(env)
       name = part[:path] || part["path"]
-      if iterm_image_protocol?(env)
-        iterm_image_sequence(data, name, width)
-      elsif kitty_image_protocol?(env)
-        kitty_image_sequence(data, name, width)
+      case protocol
+      when :iterm2
+        iterm_image_sequence(data, name, width, height, env: env)
+      when :kitty
+        return nil unless image_media_type(part) == "image/png"
+
+        kitty_image_sequence(data, name, width, height, image_id, move_cursor: move_cursor, env: env)
       end
     end
 
+    def terminal_image_protocol(env)
+      TerminalImageSupport.static_protocol(env)
+    end
+
     def iterm_image_protocol?(env)
-      env["TERM_PROGRAM"] == "iTerm.app"
+      TerminalImageSupport.iterm2_hint?(env)
     end
 
     def kitty_image_protocol?(env)
-      env["KITTY_WINDOW_ID"].to_s != "" || env["TERM"].to_s.include?("kitty") || env["TERM_PROGRAM"] == "WezTerm"
+      TerminalImageSupport.kitty_hint?(env)
+    end
+
+    def iterm_image_sequence(data, name, width, height = nil, env: ENV)
+      sequence = TerminalSequences.iterm2_image(data, name: name, width: width, height: height)
+      env["TMUX"].to_s.empty? ? sequence : TerminalSequences.tmux_passthrough(sequence)
     end
 
-    def iterm_image_sequence(data, name, width)
-      params = ["inline=1", "preserveAspectRatio=1", "width=#{width}"]
-      params << "name=#{Base64.strict_encode64(File.basename(name))}" if name
-      "\e]1337;File=#{params.join(";")}:#{data}\a"
+    def kitty_image_sequence(data, _name, width, height = nil, image_id = nil, move_cursor: true, env: ENV)
+      sequence = TerminalSequences.kitty_graphics(
+        data,
+        image_id: image_id,
+        columns: width,
+        rows: height,
+        move_cursor: move_cursor
+      )
+      env["TMUX"].to_s.empty? ? sequence : TerminalSequences.tmux_passthrough(sequence)
     end
 
-    def kitty_image_sequence(data, name, width)
-      params = ["inline=1", "preserveAspectRatio=1", "width=#{width}"]
-      params << "name=#{Base64.strict_encode64(File.basename(name))}" if name
-      "\e_G#{params.join(";")}:#{data}\e\\"
+    def image_media_type(part)
+      part[:media_type] || part["media_type"] || part[:mimeType] || part["mimeType"]
     end
   end
 end

data/lib/kward/interactive_pty_runner.rb

@@ -2,10 +2,11 @@ require "io/console"
 require "pty"
 require "timeout"
 require_relative "local_pty_command_runner"
+require_relative "pty_output_sink"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
-  # Runs a command in a PTY while forwarding caller-owned input and output IOs.
+  # Runs a command in a PTY while forwarding caller-owned input and output sink.
   # This is intentionally low level: UI orchestration decides when terminal
   # ownership is handed to the child process and how the result is presented.
   class InteractivePtyRunner
@@ -18,7 +19,7 @@ module Kward
       @window_size = nil
     end
 
-    def run(*command, env: {}, cwd: Dir.pwd, input: $stdin, output: $stdout, &block)
+    def run(*command, env: {}, cwd: Dir.pwd, input: $stdin, sink:)
       pid = nil
       status = nil
       writer = nil
@@ -29,9 +30,11 @@ module Kward
         writer = child_writer
         update_window_size(reader, pid)
         with_raw_input(input) do
-          drain_initial_input(input, writer)
-          status, input_forwarded = forward_io(reader, writer, pid, input, output, &block)
+          input_forwarded = drain_initial_input(input, writer, sink)
+          status, forwarded = forward_io(reader, writer, pid, input, sink)
+          input_forwarded ||= forwarded
         end
+        sink.finish if sink.respond_to?(:finish)
         status ||= wait_for_status(pid)
       end
 
@@ -57,19 +60,23 @@ module Kward
       yield
     end
 
-    def drain_initial_input(input, writer)
+    def drain_initial_input(input, writer, sink)
+      forwarded = false
       loop do
         chunk = input.read_nonblock(READ_SIZE, exception: false)
         break if chunk.nil? || chunk == :wait_readable
 
+        sink.input_forwarded if sink.respond_to?(:input_forwarded)
         writer.write(chunk)
+        forwarded = true
       end
       writer.flush
+      forwarded
     rescue Errno::EIO, Errno::EPIPE, IOError
-      nil
+      forwarded
     end
 
-    def forward_io(reader, writer, pid, input, output, &block)
+    def forward_io(reader, writer, pid, input, sink)
       input_open = true
       input_forwarded = false
       loop do
@@ -77,9 +84,9 @@ module Kward
         readers = [reader]
         readers << input if input_open
         readable = IO.select(readers, nil, nil, 0.02)&.first || []
-        forward_pty_output(reader, output, &block) if readable.include?(reader)
+        forward_pty_output(reader, sink) if readable.include?(reader)
         if input_open && readable.include?(input)
-          input_open, forwarded = forward_input(input, writer)
+          input_open, forwarded = forward_input(input, writer, sink)
           input_forwarded ||= forwarded
         end
 
@@ -88,23 +95,22 @@ module Kward
 
         return [finish_stopped_process(pid), input_forwarded] if status.stopped?
 
-        drain_pty_output(reader, output, &block)
+        drain_pty_output(reader, sink)
         return [status, input_forwarded]
       rescue Errno::EIO
         return [wait_for_status(pid), input_forwarded]
       end
     end
 
-    def forward_pty_output(reader, output)
+    def forward_pty_output(reader, sink)
       chunk = reader.read_nonblock(READ_SIZE, exception: false)
       return if chunk.nil? || chunk == :wait_readable
 
-      output.write(chunk)
-      output.flush if output.respond_to?(:flush)
-      yield chunk if block_given?
+      sink.write(chunk)
+      sink.flush if sink.respond_to?(:flush)
     end
 
-    def drain_pty_output(reader, output)
+    def drain_pty_output(reader, sink)
       loop do
         readable, = IO.select([reader], nil, nil, 0.02)
         break unless readable
@@ -112,19 +118,19 @@ module Kward
         chunk = reader.read_nonblock(READ_SIZE, exception: false)
         break if chunk.nil? || chunk == :wait_readable
 
-        output.write(chunk)
-        yield chunk if block_given?
+        sink.write(chunk)
       end
-      output.flush if output.respond_to?(:flush)
+      sink.flush if sink.respond_to?(:flush)
     rescue Errno::EIO
       nil
     end
 
-    def forward_input(input, writer)
+    def forward_input(input, writer, sink)
       chunk = input.read_nonblock(READ_SIZE, exception: false)
       return [false, false] if chunk.nil?
       return [true, false] if chunk == :wait_readable
 
+      sink.input_forwarded if sink.respond_to?(:input_forwarded)
       writer.write(chunk)
       writer.flush
       [true, true]

data/lib/kward/model/client.rb

@@ -906,7 +906,7 @@ module Kward
       request["Content-Type"] = "application/json"
       request["Accept"] = "text/event-stream"
       request.body = request_body || JSON.dump(codex_payload(messages, tools, max_tokens: max_tokens))
-      apply_codex_identity(request, luna: luna_request?(request.body))
+      request["originator"] = "kward"
 
       message = nil
       Net::HTTP.start(url.hostname, url.port, use_ssl: true, read_timeout: stream_idle_timeout_seconds) do |http|
@@ -931,22 +931,6 @@ module Kward
       raise e
     end
 
-    def apply_codex_identity(request, luna:)
-      request["originator"] = "kward"
-      return unless luna
-
-      # TODO: Remove this Luna-specific Responses Lite workaround when Codex accepts Kward's own client identity.
-      request["originator"] = "codex_cli_rs"
-      request["User-Agent"] = "codex_cli_rs/0.144.1"
-      request["x-openai-internal-codex-responses-lite"] = "true"
-    end
-
-    def luna_request?(request_body)
-      JSON.parse(request_body)["model"] == "gpt-5.6-luna"
-    rescue JSON::ParserError
-      false
-    end
-
     def parse_codex_sse(body, on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil)
       ModelStreamParser.parse_codex_sse(body, on_reasoning_delta: on_reasoning_delta, on_reasoning_boundary: on_reasoning_boundary, on_assistant_delta: on_assistant_delta, show_raw_reasoning: codex_show_raw_reasoning?, usage_normalizer: method(:normalized_usage), request_error_class: RequestError)
     end

data/lib/kward/model/model_info.rb

@@ -12,6 +12,7 @@ module Kward
     OPENAI_MODEL_CHOICES = %w[gpt-5.6-sol gpt-5.6-terra gpt-5.6-luna gpt-5.5 gpt-5.4 gpt-5.4-mini gpt-5.3-codex-spark].freeze
     ANTHROPIC_MODEL_CHOICES = %w[
       claude-fable-5
+      claude-opus-5
       claude-opus-4-8
       claude-sonnet-5
       claude-sonnet-4-6
@@ -113,7 +114,7 @@ module Kward
       [/\Agpt-3\.5-turbo/, 16_385]
     ].freeze
     ANTHROPIC_CONTEXT_WINDOWS = [
-      [/\Aclaude-(?:fable|mythos|sonnet)-5(?:\z|-)/, 1_000_000],
+      [/\Aclaude-(?:fable|mythos|opus|sonnet)-5(?:\z|-)/, 1_000_000],
       [/\Aclaude-opus-4-(?:6|7|8)(?:\z|-)/, 1_000_000],
       [/\Aclaude-sonnet-4-6(?:\z|-)/, 1_000_000],
       [/\Aclaude-(?:haiku|opus|sonnet)-4-5(?:\z|-)/, 200_000],
@@ -454,7 +455,7 @@ module Kward
 
     def anthropic_reasoning_effort_choices(id)
       text = normalize_anthropic_model(id)
-      return ANTHROPIC_HIGH_REASONING_EFFORT_CHOICES if text.match?(/\Aclaude-(?:fable|mythos|sonnet)-5(?:\z|-)|\Aclaude-opus-4-(?:7|8)(?:\z|-)/)
+      return ANTHROPIC_HIGH_REASONING_EFFORT_CHOICES if text.match?(/\Aclaude-(?:fable|mythos|opus|sonnet)-5(?:\z|-)|\Aclaude-opus-4-(?:7|8)(?:\z|-)/)
       return ANTHROPIC_STANDARD_REASONING_EFFORT_CHOICES if text.match?(/\Aclaude-(?:opus-4-6|sonnet-4-6)(?:\z|-)/)
       return ANTHROPIC_OPUS_4_5_REASONING_EFFORT_CHOICES if text.match?(/\Aclaude-opus-4-5(?:\z|-)/)
 

data/lib/kward/model/payloads.rb

@@ -189,8 +189,6 @@ module Kward
       unless reasoning == false
         effort = reasoning || reasoning_effort(provider)
         payload[:reasoning] = { effort: effort, summary: "auto" }
-        # TODO: Remove this Luna-specific Responses Lite workaround when Codex accepts Kward's own client identity.
-        payload[:reasoning][:context] = "all_turns" if provider == "Codex" && parts[:model] == "gpt-5.6-luna"
       end
       payload
     end