kward 0.75.0 → 0.77.0

data/lib/kward/cli_transcript_formatter.rb

@@ -10,25 +10,31 @@ module Kward
     module_function
 
     def reasoning(message)
-      direct = MessageAccess.value(message, :reasoning_summary)
-      return direct.to_s unless direct.to_s.empty?
+      reasoning_blocks(message).join("\n")
+    end
+
+    def reasoning_blocks(message)
+      response_blocks = response_items(message).flat_map do |item|
+        next [] unless MessageAccess.value(item, :type) == "reasoning"
+
+        summary = response_item_text_parts(MessageAccess.value(item, :summary))
+        summary.empty? ? response_item_text_parts(MessageAccess.value(item, :content)) : summary
+      end
+      return response_blocks unless response_blocks.empty?
 
       content = MessageAccess.content(message)
       if content.is_a?(Array)
-        text = content.filter_map do |part|
+        blocks = content.filter_map do |part|
           type = MessageAccess.value(part, :type)
           next unless ["thinking", "reasoning"].include?(type)
 
           MessageAccess.value(part, :thinking) || MessageAccess.value(part, :reasoning) || MessageAccess.value(part, :text)
-        end.join("\n")
-        return text unless text.empty?
+        end.map(&:to_s).reject(&:empty?)
+        return blocks unless blocks.empty?
       end
 
-      response_items(message).filter_map do |item|
-        next unless MessageAccess.value(item, :type) == "reasoning"
-
-        response_item_text(MessageAccess.value(item, :summary)).empty? ? response_item_text(MessageAccess.value(item, :content)) : response_item_text(MessageAccess.value(item, :summary))
-      end.join("\n")
+      direct = MessageAccess.value(message, :reasoning_summary).to_s
+      direct.empty? ? [] : [direct]
     end
 
     def content_text(content)
@@ -113,11 +119,15 @@ module Kward
     end
 
     def response_item_text(parts)
+      response_item_text_parts(parts).join
+    end
+
+    def response_item_text_parts(parts)
       Array(parts).filter_map do |part|
         next unless part.is_a?(Hash)
 
         MessageAccess.value(part, :text) || MessageAccess.value(part, :refusal)
-      end.join
+      end.map(&:to_s).reject(&:empty?)
     end
 
     def image_part_reference(part)

data/lib/kward/compactor.rb

@@ -37,7 +37,7 @@ module Kward
 
     Cut = Struct.new(:first_kept_index, :messages_to_summarize, :turn_prefix_messages, :split_turn, :preserved_messages, :preserved_start_index, keyword_init: true)
 
-    # Interactive settings menu actions mixed into the CLI frontend.
+    # Configuration for manual and automatic conversation compaction.
     class Settings
       DEFAULT_ENABLED = true
       DEFAULT_RESERVE_TOKENS = 16_384
@@ -731,7 +731,7 @@ module Kward
     SummarizationFailed = Compaction::SummarizationFailed
 
     AUTO_COMPACTION_GUARD_RATIO = 0.10
-    AUTO_COMPACTION_EXTRA_GUARD_CAP = 12_000
+    AUTO_COMPACTION_EXTRA_GUARD_FLOOR = 12_000
 
     # Creates an object for conversation compaction.
     def initialize(conversation:, client:, tool_result_summarizer: nil, settings: nil, summarizer: nil)
@@ -805,7 +805,7 @@ module Kward
     def self.auto_compaction_reserve_tokens(context_window:, configured_reserve_tokens:)
       context_window_i = context_window.to_i
       dynamic_guard = (context_window_i * AUTO_COMPACTION_GUARD_RATIO).to_i
-      [configured_reserve_tokens.to_i, dynamic_guard, AUTO_COMPACTION_EXTRA_GUARD_CAP].max
+      [configured_reserve_tokens.to_i, dynamic_guard, AUTO_COMPACTION_EXTRA_GUARD_FLOOR].max
     end
 
     def compaction_messages(custom_instructions = nil)

data/lib/kward/config_files.rb

@@ -24,7 +24,9 @@ module Kward
   # Keep path decisions here. Higher-level code should ask `ConfigFiles` for
   # config, prompt, skill, plugin, cache, memory, and session locations instead of
   # reconstructing `~/.kward` paths independently.
+  # @api public
   module ConfigFiles
+    # Raised when a user configuration file cannot be parsed.
     class ConfigError < StandardError
       attr_reader :path, :format, :detail
 
@@ -39,6 +41,7 @@ module Kward
     MAX_SKILL_FILE_BYTES = 100_000
     MAX_PROMPT_FILE_BYTES = 32 * 1024
     DEFAULT_OVERLAY_SETTINGS = { "alignment" => "center", "width" => "maximum" }.freeze
+    PROJECT_BROWSER_ICON_THEMES = %w[off nerd-font].freeze
     DEFAULT_PERSONAS = {
       "characters" => [
         {
@@ -87,10 +90,12 @@ module Kward
       File.expand_path(ENV["KWARD_CONFIG_PATH"] || File.join(config_dir, "config.json"))
     end
 
+    # @return [String] directory containing reusable local caches
     def cache_dir
       File.join(config_dir, "cache")
     end
 
+    # @return [String] embedded-shell YAML config path
     def ekwsh_config_path
       File.join(config_dir, "ekwsh.yml")
     end
@@ -103,6 +108,9 @@ module Kward
       File.join(config_dir, "trusted_workspace_hooks.json")
     end
 
+    # Returns a fresh default config suitable for first-run persistence.
+    #
+    # @return [Hash] deep-mutable config defaults
     def default_config
       {
         "personas" => JSON.parse(JSON.generate(DEFAULT_PERSONAS)),
@@ -124,11 +132,17 @@ module Kward
           "diff_view" => "auto"
         },
         "overlay" => DEFAULT_OVERLAY_SETTINGS.dup,
+        "project_browser" => {
+          "icons" => "off"
+        },
         "web_search" => {
           "enabled" => true,
           "provider" => "auto",
           "allow_model_providers" => false
         },
+        "updates" => {
+          "check" => true
+        },
         "sessions" => {
           "auto_resume" => false
         },
@@ -406,6 +420,13 @@ module Kward
       settings
     end
 
+    # Returns the project browser icon theme, or off when unset or invalid.
+    def project_browser_icon_theme(config = read_config)
+      browser = config["project_browser"].is_a?(Hash) ? config["project_browser"] : {}
+      theme = browser["icons"].to_s
+      PROJECT_BROWSER_ICON_THEMES.include?(theme) ? theme : "off"
+    end
+
     # Returns whether the composer should show busy-state keyboard help.
     def composer_busy_help?(config = read_config)
       composer = config["composer"].is_a?(Hash) ? config["composer"] : {}

data/lib/kward/ekwsh.rb

@@ -551,9 +551,5 @@ module Kward
       ANSI.sanitize_transcript(text)
     end
 
-    def clean_output(value)
-      text = clean_chunk(value)
-      text.end_with?("\n") || text.empty? ? text : "#{text}\n"
-    end
   end
 end

data/lib/kward/events.rb

@@ -3,6 +3,7 @@ module Kward
   # Frontend-neutral event objects emitted during agent turns.
   module Events
     ReasoningDelta = Struct.new(:delta, keyword_init: true)
+    ReasoningBoundary = Data.define
     AssistantDelta = Struct.new(:delta, keyword_init: true)
     AssistantMessage = Struct.new(:message, keyword_init: true)
     Retry = Struct.new(:provider, :model, :attempt, :max_attempts, :delay_seconds, :error, :request_bytes, keyword_init: true)

data/lib/kward/hooks/catalog.rb

@@ -45,11 +45,6 @@ module Kward
         EventDefinition.new(name: "git_stage_after", failure_policy: "warn"),
         EventDefinition.new(name: "git_commit_before", failure_policy: "deny"),
         EventDefinition.new(name: "git_commit_after", failure_policy: "warn"),
-        EventDefinition.new(name: "worker_job_create", failure_policy: "warn"),
-        EventDefinition.new(name: "worker_job_start_before", failure_policy: "warn"),
-        EventDefinition.new(name: "worker_job_start_after", failure_policy: "warn"),
-        EventDefinition.new(name: "worker_job_ready_for_review", failure_policy: "warn"),
-        EventDefinition.new(name: "worker_job_failed", failure_policy: "warn")
       ].each_with_object({}) { |definition, result| result[definition.name] = definition }.freeze
 
       module_function

data/lib/kward/image_attachments.rb

@@ -1,5 +1,5 @@
 require "base64"
-require "cgi"
+require "cgi/escape"
 require "shellwords"
 require "tmpdir"
 require "uri"

data/lib/kward/model/client.rb

@@ -94,7 +94,7 @@ module Kward
       @openrouter_models = nil
     end
 
-    def chat(messages, tools: [], on_reasoning_delta: nil, on_assistant_delta: nil, on_retry: nil, cancellation: nil, steering: nil, max_tokens: nil, provider: nil, model: nil, reasoning: nil)
+    def chat(messages, tools: [], on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, on_retry: nil, cancellation: nil, steering: nil, max_tokens: nil, provider: nil, model: nil, reasoning: nil)
       cancellation&.raise_if_cancelled!
       requested_provider = provider
       url, token, resolved_provider, account_id = credentials(provider: requested_provider)
@@ -126,6 +126,7 @@ module Kward
             request_body: request_body,
             current_model: current_model,
             on_reasoning_delta: on_reasoning_delta,
+            on_reasoning_boundary: on_reasoning_boundary,
             on_assistant_delta: on_assistant_delta,
             cancellation: cancellation,
             max_tokens: max_tokens
@@ -257,7 +258,7 @@ module Kward
       }
     end
 
-    def chat_provider_request(provider:, url:, token:, account_id:, messages:, tools:, request_body:, current_model:, on_reasoning_delta:, on_assistant_delta:, cancellation:, max_tokens:)
+    def chat_provider_request(provider:, url:, token:, account_id:, messages:, tools:, request_body:, current_model:, on_reasoning_delta:, on_reasoning_boundary:, on_assistant_delta:, cancellation:, max_tokens:)
       case provider
       when "Codex"
         chat_codex_provider(
@@ -269,6 +270,7 @@ module Kward
           request_body: request_body,
           current_model: current_model,
           on_reasoning_delta: on_reasoning_delta,
+          on_reasoning_boundary: on_reasoning_boundary,
           on_assistant_delta: on_assistant_delta,
           cancellation: cancellation,
           max_tokens: max_tokens
@@ -306,7 +308,7 @@ module Kward
       end
     end
 
-    def chat_codex_provider(url:, token:, account_id:, messages:, tools:, request_body:, current_model:, on_reasoning_delta:, on_assistant_delta:, cancellation:, max_tokens:)
+    def chat_codex_provider(url:, token:, account_id:, messages:, tools:, request_body:, current_model:, on_reasoning_delta:, on_reasoning_boundary:, on_assistant_delta:, cancellation:, max_tokens:)
       message = codex_chat(
         url,
         token,
@@ -315,6 +317,7 @@ module Kward
         tools,
         request_body: request_body,
         on_reasoning_delta: on_reasoning_delta,
+        on_reasoning_boundary: on_reasoning_boundary,
         on_assistant_delta: on_assistant_delta,
         cancellation: cancellation,
         max_tokens: max_tokens
@@ -649,7 +652,7 @@ module Kward
       role.to_s == "user" ? "user" : "agent"
     end
 
-    def codex_chat(url, token, account_id, messages, tools, request_body: nil, on_reasoning_delta: nil, on_assistant_delta: nil, cancellation: nil, max_tokens: nil)
+    def codex_chat(url, token, account_id, messages, tools, request_body: nil, on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, cancellation: nil, max_tokens: nil)
       request = Net::HTTP::Post.new(url)
       request["Authorization"] = "Bearer #{token}"
       request["ChatGPT-Account-Id"] = account_id if account_id
@@ -669,7 +672,7 @@ module Kward
             raise RequestError.new(provider: "Codex", code: response.code, body: redact(body, token))
           end
 
-          message = parse_codex_sse_stream(response, on_reasoning_delta: on_reasoning_delta, on_assistant_delta: on_assistant_delta, cancellation: cancellation)
+          message = parse_codex_sse_stream(response, on_reasoning_delta: on_reasoning_delta, on_reasoning_boundary: on_reasoning_boundary, on_assistant_delta: on_assistant_delta, cancellation: cancellation)
         end
       end
 
@@ -681,12 +684,12 @@ module Kward
       raise e
     end
 
-    def parse_codex_sse(body, on_reasoning_delta: nil, on_assistant_delta: nil)
-      ModelStreamParser.parse_codex_sse(body, on_reasoning_delta: on_reasoning_delta, on_assistant_delta: on_assistant_delta, show_raw_reasoning: codex_show_raw_reasoning?, usage_normalizer: method(:normalized_usage), request_error_class: RequestError)
+    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
 
-    def parse_codex_sse_stream(response, on_reasoning_delta: nil, on_assistant_delta: nil, cancellation: nil)
-      ModelStreamParser.parse_codex_sse_stream(response, on_reasoning_delta: on_reasoning_delta, on_assistant_delta: on_assistant_delta, cancellation: cancellation, show_raw_reasoning: codex_show_raw_reasoning?, usage_normalizer: method(:normalized_usage), request_error_class: RequestError)
+    def parse_codex_sse_stream(response, on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, cancellation: nil)
+      ModelStreamParser.parse_codex_sse_stream(response, on_reasoning_delta: on_reasoning_delta, on_reasoning_boundary: on_reasoning_boundary, on_assistant_delta: on_assistant_delta, cancellation: cancellation, show_raw_reasoning: codex_show_raw_reasoning?, usage_normalizer: method(:normalized_usage), request_error_class: RequestError)
     end
 
     def parse_anthropic_sse_stream(response, on_reasoning_delta: nil, on_assistant_delta: nil, cancellation: nil)

data/lib/kward/model/model_info.rb

@@ -4,13 +4,15 @@ require_relative "../config_files"
 module Kward
   # Static and configured model metadata helpers.
   module ModelInfo
-    DEFAULT_OPENAI_MODEL = "gpt-5.5"
+    DEFAULT_OPENAI_MODEL = "gpt-5.6-sol"
     DEFAULT_COPILOT_MODEL = "gpt-5-mini"
-    DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-4-6"
+    DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-5"
     DEFAULT_REASONING_EFFORT = "medium"
-    OPENAI_MODEL_CHOICES = %w[gpt-5.5 gpt-5.4 gpt-5.4-mini gpt-5.3-codex-spark].freeze
+    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-4-8
+      claude-sonnet-5
       claude-sonnet-4-6
       claude-haiku-4-5
       claude-opus-4-7
@@ -46,6 +48,10 @@ module Kward
       ["none", "None"],
       *REASONING_EFFORT_CHOICES
     ].freeze
+    OPENAI_MAX_REASONING_EFFORT_CHOICES = [
+      *OPENAI_REASONING_EFFORT_CHOICES,
+      ["max", "Max"]
+    ].freeze
     ANTHROPIC_HIGH_REASONING_EFFORT_CHOICES = [
       ["low", "Low"],
       ["medium", "Medium"],
@@ -70,6 +76,7 @@ module Kward
     ].freeze
 
     CODEX_CONTEXT_WINDOWS = [
+      [/\Agpt-5\.6/, 1_050_000],
       [/\Agpt-5\.5/, 400_000],
       [/\Agpt-5\.4-mini/, 400_000],
       [/\Agpt-5\.4/, 1_050_000],
@@ -87,6 +94,7 @@ module Kward
       [/\Agpt-3\.5-turbo/, 16_385]
     ].freeze
     OPENAI_CONTEXT_WINDOWS = [
+      [/\Agpt-5\.6/, 1_050_000],
       [/\Agpt-5\.5/, 1_050_000],
       [/\Agpt-5\.4-mini/, 400_000],
       [/\Agpt-5\.4/, 1_050_000],
@@ -104,7 +112,7 @@ module Kward
       [/\Agpt-3\.5-turbo/, 16_385]
     ].freeze
     ANTHROPIC_CONTEXT_WINDOWS = [
-      [/\Aclaude-(?:fable|mythos)-5(?:\z|-)/, 1_000_000],
+      [/\Aclaude-(?:fable|mythos|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],
@@ -382,13 +390,14 @@ module Kward
     def openai_reasoning_effort_choices(id)
       text = id.to_s.delete_prefix("openai/")
       return REASONING_EFFORT_CHOICES if text.match?(/\Agpt-5\.[23]-codex/)
+      return OPENAI_MAX_REASONING_EFFORT_CHOICES if text.match?(/\Agpt-5\.6(?:\z|-)/)
 
       OPENAI_REASONING_EFFORT_CHOICES
     end
 
     def anthropic_reasoning_effort_choices(id)
       text = normalize_anthropic_model(id)
-      return ANTHROPIC_HIGH_REASONING_EFFORT_CHOICES if text.match?(/\Aclaude-(?:fable|mythos)-5(?:\z|-)|\Aclaude-opus-4-(?:7|8)(?:\z|-)/)
+      return ANTHROPIC_HIGH_REASONING_EFFORT_CHOICES if text.match?(/\Aclaude-(?:fable|mythos|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/stream_parser.rb

@@ -45,10 +45,10 @@ module Kward
       raise "Copilot returned invalid SSE JSON: #{e.message}"
     end
 
-    def parse_codex_sse(body, on_reasoning_delta: nil, on_assistant_delta: nil, show_raw_reasoning: false, usage_normalizer: nil, request_error_class: nil)
+    def parse_codex_sse(body, on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, show_raw_reasoning: false, usage_normalizer: nil, request_error_class: nil)
       state = codex_sse_state(show_raw_reasoning: show_raw_reasoning)
       body.split(/\r?\n\r?\n/).each do |block|
-        process_codex_sse_block(block, state, on_reasoning_delta: on_reasoning_delta, on_assistant_delta: on_assistant_delta, usage_normalizer: usage_normalizer, request_error_class: request_error_class)
+        process_codex_sse_block(block, state, on_reasoning_delta: on_reasoning_delta, on_reasoning_boundary: on_reasoning_boundary, on_assistant_delta: on_assistant_delta, usage_normalizer: usage_normalizer, request_error_class: request_error_class)
       end
       flush_codex_reasoning_delta(state, on_reasoning_delta: on_reasoning_delta)
       codex_sse_message(state)
@@ -61,7 +61,7 @@ module Kward
     # Deltas are yielded as soon as complete SSE blocks arrive so interactive
     # frontends can render streamed assistant and reasoning text without waiting
     # for the provider to close the response.
-    def parse_codex_sse_stream(response, on_reasoning_delta: nil, on_assistant_delta: nil, cancellation: nil, show_raw_reasoning: false, usage_normalizer: nil, request_error_class: nil)
+    def parse_codex_sse_stream(response, on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, cancellation: nil, show_raw_reasoning: false, usage_normalizer: nil, request_error_class: nil)
       state = codex_sse_state(show_raw_reasoning: show_raw_reasoning)
       buffer = +""
 
@@ -72,11 +72,11 @@ module Kward
           delimiter = Regexp.last_match[0]
           block = buffer[0...index]
           buffer = buffer[(index + delimiter.length)..] || +""
-          process_codex_sse_block(block, state, on_reasoning_delta: on_reasoning_delta, on_assistant_delta: on_assistant_delta, usage_normalizer: usage_normalizer, request_error_class: request_error_class)
+          process_codex_sse_block(block, state, on_reasoning_delta: on_reasoning_delta, on_reasoning_boundary: on_reasoning_boundary, on_assistant_delta: on_assistant_delta, usage_normalizer: usage_normalizer, request_error_class: request_error_class)
         end
       end
       cancellation&.raise_if_cancelled!
-      process_codex_sse_block(buffer, state, on_reasoning_delta: on_reasoning_delta, on_assistant_delta: on_assistant_delta, usage_normalizer: usage_normalizer, request_error_class: request_error_class) unless buffer.empty?
+      process_codex_sse_block(buffer, state, on_reasoning_delta: on_reasoning_delta, on_reasoning_boundary: on_reasoning_boundary, on_assistant_delta: on_assistant_delta, usage_normalizer: usage_normalizer, request_error_class: request_error_class) unless buffer.empty?
       flush_codex_reasoning_delta(state, on_reasoning_delta: on_reasoning_delta)
       codex_sse_message(state)
     rescue JSON::ParserError => e
@@ -239,7 +239,7 @@ module Kward
       }
     end
 
-    def process_codex_sse_block(block, state, on_reasoning_delta: nil, on_assistant_delta: nil, usage_normalizer: nil, request_error_class: nil)
+    def process_codex_sse_block(block, state, on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, usage_normalizer: nil, request_error_class: nil)
       data = block.lines.filter_map { |line| line.start_with?("data:") ? line.delete_prefix("data:").strip : nil }.join("\n")
       return if data.empty? || data == "[DONE]"
 
@@ -256,7 +256,7 @@ module Kward
       when "response.reasoning_summary_text.delta"
         codex_reasoning_delta(state, event["delta"], on_reasoning_delta: on_reasoning_delta)
       when "response.reasoning_summary_part.done"
-        codex_reasoning_part_done(state, on_reasoning_delta: on_reasoning_delta)
+        codex_reasoning_part_done(state, on_reasoning_delta: on_reasoning_delta, on_reasoning_boundary: on_reasoning_boundary)
       when "response.reasoning_text.delta"
         codex_raw_reasoning_delta(state, event["delta"], on_reasoning_delta: on_reasoning_delta)
       when "response.reasoning_text.done"
@@ -391,16 +391,16 @@ module Kward
       append_codex_raw_reasoning_text(state, text, on_reasoning_delta: on_reasoning_delta) unless text.empty?
     end
 
-    def codex_reasoning_part_done(state, on_reasoning_delta: nil)
+    def codex_reasoning_part_done(state, on_reasoning_delta: nil, on_reasoning_boundary: nil)
       item = active_codex_item(state)
       return unless item&.fetch("type", nil) == "reasoning"
       return if item["summary"].to_a.empty?
 
       flush_codex_reasoning_delta(state, on_reasoning_delta: on_reasoning_delta)
-      text = "\n\n"
-      item["summary"].last["text"] = item["summary"].last["text"].to_s + text
-      state[:reasoning_summary] << text
-      on_reasoning_delta&.call(text)
+      item["summary"].last["text"] = "#{item["summary"].last["text"].to_s.rstrip}\n\n"
+      state[:reasoning_summary].rstrip!
+      state[:reasoning_summary] << "\n\n"
+      on_reasoning_boundary&.call
     end
 
     def append_codex_reasoning_text(state, text, on_reasoning_delta: nil)