kward 0.75.0 → 0.76.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 063b8f53ff1a13adc3171af1201b12dcbbd014b59edf37c61f963614ceb79ea5
-  data.tar.gz: db3f8715d8e648326a3d1dbf746636092dca709addadc6e629acec11016d5e13
+  metadata.gz: bd9108129c3abd1aebeb3d1adb3e9011fbaf4e96c60a4f2ff55505497ff4fd0c
+  data.tar.gz: 14177ca73389b1e2df9239706f20b879d22322ec89e72f31a81aa573915b0b91
 SHA512:
-  metadata.gz: c483b653b15e10415ec322dfea7f0e3a23df7e416260eaaf91d66cb711348573f4ecc642db07b55786f0f01389f5421549293a5c2ead483947152d5702909572
-  data.tar.gz: faa9827cdc03b0d48fdee98f4ecf40b7157ed8989800236226adc138d8ecabe52855a67d472c85174d0a3365527ed4aab9ec63ded872a61ba9e85c62b08a4c8b
+  metadata.gz: 787448090be2990a36e9d6d5c1911ce3bc5f6031f7c946a6d5d3edde3b78a43742227df6257d64c04e15def86a579e91366db602187200f1c08d241ae705d3b4
+  data.tar.gz: 9a18e14824b3f38d2d1e030adf706629a4e797cd49a8aa1c23786fb53d174e4e81a3d1462c6e7a15de4efa1df517f0aaed7eba89fab1d94f162ba066fff59743

data/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to Kward will be documented in this file.
 
 ## [Unreleased]
 
+## [0.76.0] - 2026-07-10
+
+### Added
+
+- Added GPT-5.6 Sol, Terra, and Luna to the OpenAI/Codex model choices and made GPT-5.6 Sol the default OpenAI/Codex model.
+- Added Claude Sonnet 5 and Fable 5 to the Anthropic model choices and made Claude Sonnet 5 the default Anthropic model.
+
+### Fixed
+
+- Fixed Codex reasoning summaries so separate summary messages render as separate blocks with one empty line between transcript blocks.
+- Fixed interactive update notices so stale checks refresh before the startup banner and new configs expose the `updates.check` setting.
+
 ## [0.75.0] - 2026-07-09
 
 ### Added

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kward (0.75.0)
+    kward (0.76.0)
       base64
       nokogiri
       tiktoken_ruby
@@ -146,7 +146,7 @@ CHECKSUMS
   html-proofer (5.2.1) sha256=fdd958a7cbf9c3255fb96fe7cfc4e611f64e2706e469488a3326309ad007d2fd
   io-event (1.16.2) sha256=9f9cb0a96ea5c3850a672606c65f27bc96d7621399ef6196acbfe2be0cd1279c
   json (2.19.9) sha256=9b9025b7cdddafa38d316eca0b2358488e42d417045c1b90d216a9fefe46b79a
-  kward (0.75.0)
+  kward (0.76.0)
   logger (1.7.0) sha256=196edec7cc44b66cfb40f9755ce11b392f21f7967696af15d274dde7edff0203
   metrics (0.15.0) sha256=61ded5bac95118e995b1bc9ed4a5f19bc9814928a312a85b200abbdac9039072
   minitest (6.0.6) sha256=153ea36d1d987a62942382b61075745042a2b3123b1cd48f4c3675af9cc7d6f1

data/doc/configuration.md

@@ -9,7 +9,7 @@ Small examples:
 ```json
 {
   "provider": "openrouter",
-  "openrouter_model": "openai/gpt-5.5"
+  "openrouter_model": "openai/gpt-5.6-sol"
 }
 ```
 
@@ -36,6 +36,16 @@ See [MCP servers](mcp.md) for connecting local Model Context Protocol servers su
 
 By default, Kward loads user-level skills but skips project-level skills from the workspace. Set `skills.trust_project` to `true`, or use `/settings` → `Tools & Search` → `Trust project skills`, when you trust the repository's `.kward/skills` or `.agents/skills` directories. See [Skills](skills.md) for skill locations and examples.
 
+```json
+{
+  "updates": {
+    "check": true
+  }
+}
+```
+
+Kward checks RubyGems for newer `kward` versions on the interactive startup screen. Results are cached under `~/.kward/cache/update_check.json` so startup does not hit RubyGems every time. Set `updates.check` to `false`, or set `KWARD_DISABLE_UPDATE_CHECK=1`, to disable the check.
+
 ```json
 {
   "memory": {
@@ -131,10 +141,10 @@ Model settings:
 
 ```json
 {
-  "model": "gpt-5.5",
-  "openai_model": "gpt-5.5",
-  "openrouter_model": "openai/gpt-5.5",
-  "anthropic_model": "claude-sonnet-4-5",
+  "model": "gpt-5.6-sol",
+  "openai_model": "gpt-5.6-sol",
+  "openrouter_model": "openai/gpt-5.6-sol",
+  "anthropic_model": "claude-sonnet-5",
   "copilot_model": "gpt-5-mini",
   "reasoning_effort": "medium",
   "openai_reasoning_effort": "medium",
@@ -151,12 +161,14 @@ Set `codex_show_raw_reasoning` to `true` to display raw Codex `reasoning_text` w
 
 Defaults:
 
-- OpenAI/Codex: `gpt-5.5`
-- OpenRouter: `openai/gpt-5.5`
-- Anthropic: `claude-sonnet-4-6`
+- OpenAI/Codex: `gpt-5.6-sol`
+- OpenRouter: `openai/gpt-5.6-sol`
+- Anthropic: `claude-sonnet-5`
 - Copilot: `gpt-5-mini`
 - Reasoning effort: `medium`
 
+The Anthropic model choices include `claude-fable-5`, but Fable availability depends on the logged-in account and organization. Selecting it without access returns an Anthropic provider error.
+
 The interactive `/model` picker reads cached OpenRouter models when available. Run `kward openrouter refresh` to fetch text-capable models available to the configured OpenRouter API key and cache them under `~/.kward/cache/openrouter_models.json`. Run `kward openrouter list` to inspect the cached model ids.
 
 ## Environment overrides

data/doc/plugins.md

@@ -199,6 +199,7 @@ Event payloads are read-only copies. Handler errors are caught and printed as wa
 Common event types include:
 
 - `reasoning_delta`
+- `reasoning_boundary`
 - `assistant_delta`
 - `assistant_message`
 - `model_retry`

data/doc/rpc.md

@@ -357,6 +357,7 @@ Known event types:
 - `steeringApplied`
 - `turnStarted`
 - `reasoningDelta`
+- `reasoningBoundary`
 - `assistantDelta`
 - `assistantMessage`
 - `modelRetry`
@@ -368,6 +369,8 @@ Known event types:
 - `error`
 - `turnFinished`
 
+`reasoningBoundary` has an empty payload and marks the end of one reasoning summary message, allowing clients to render the next `reasoningDelta` as a separate block.
+
 Lifecycle payloads include `status` for `turnQueued`, `turnStarted`, and `turnFinished`. Exactly one terminal `turnFinished` is emitted per turn with `status` set to `completed`, `failed`, or `canceled`; failed turns include a sanitized `{ "message": "...", "code": "...", "fatal": false }` error payload.
 
 `modelRetry` is emitted before Kward retries a transient model request failure. Its payload includes `provider`, `model`, `attempt`, `maxAttempts`, `delaySeconds`, and `error`.

data/lib/kward/agent.rb

@@ -215,6 +215,10 @@ module Kward
         on_reasoning_delta&.call(delta)
         yield Events::ReasoningDelta.new(delta: delta) if block_given?
       end
+      reasoning_boundary = lambda do
+        cancellation&.raise_if_cancelled!
+        yield Events::ReasoningBoundary.new if block_given?
+      end
       assistant_delta = lambda do |delta|
         cancellation&.raise_if_cancelled!
         yield Events::AssistantDelta.new(delta: delta) if block_given?
@@ -244,6 +248,7 @@ module Kward
         {
           tools: request[:tools] || request["tools"],
           on_reasoning_delta: reasoning_delta,
+          on_reasoning_boundary: reasoning_boundary,
           on_assistant_delta: assistant_delta,
           on_retry: retry_callback,
           cancellation: cancellation,

data/lib/kward/cli/interactive_turn.rb

@@ -116,6 +116,9 @@ module Kward
         when Events::ReasoningDelta
           stream_state[:streamed] = true
           append_markdown_delta(markdown_chunks, "Reasoning", event.delta)
+        when Events::ReasoningBoundary
+          stream_state[:streamed] = true
+          finish_interactive_markdown_deltas(markdown_chunks, stream_state)
         when Events::AssistantDelta
           stream_state[:streamed] = true
           append_markdown_delta(markdown_chunks, "Assistant", event.delta)

data/lib/kward/cli/prompt_interface.rb

@@ -70,13 +70,12 @@ module Kward
       def print_visual_banner
         return unless @prompt.respond_to?(:print_visual_banner)
 
-        @prompt.print_visual_banner(startup_info_screen)
-        refresh_startup_update_check if prompt_interface?
+        @prompt.print_visual_banner(startup_info_screen(refresh_update_check: prompt_interface?))
       end
 
-      def startup_info_screen
+      def startup_info_screen(refresh_update_check: false)
         [
-          startup_status_line,
+          startup_status_line(refresh_update_check: refresh_update_check),
           *startup_update_notice_lines,
           "",
           startup_info_line("Workspace", startup_workspace_label),
@@ -119,8 +118,8 @@ module Kward
         filenames.empty? ? "none" : filenames.join(", ")
       end
 
-      def startup_status_line
-        color = startup_update_notice ? :yellow : :green
+      def startup_status_line(refresh_update_check: false)
+        color = startup_update_notice(refresh: refresh_update_check) ? :yellow : :green
         "#{ANSI.colorize("●", color, enabled: @color_enabled)} Kward v#{Kward::VERSION} is online."
       end
 
@@ -134,18 +133,11 @@ module Kward
         ]
       end
 
-      def startup_update_notice
-        return @startup_update_notice if defined?(@startup_update_notice)
+      def startup_update_notice(refresh: false)
+        return @startup_update_notice if defined?(@startup_update_notice) && !refresh
 
-        @startup_update_check = UpdateCheck.new(current_version: Kward::VERSION)
-        @startup_update_notice = @startup_update_check.notice
-      end
-
-      def refresh_startup_update_check
-        checker = @startup_update_check || UpdateCheck.new(current_version: Kward::VERSION)
-        return unless checker.enabled?
-
-        Thread.new { checker.refresh_if_stale }
+        @startup_update_check ||= UpdateCheck.new(current_version: Kward::VERSION)
+        @startup_update_notice = @startup_update_check.notice(refresh: refresh)
       end
 
       def startup_info_line(label, value)

data/lib/kward/cli/rendering.rb

@@ -38,8 +38,9 @@ module Kward
       end
 
       def render_reasoning(message)
-        reasoning = CLITranscriptFormatter.reasoning(message)
-        render_transcript_block("Reasoning", reasoning) unless reasoning.empty?
+        CLITranscriptFormatter.reasoning_blocks(message).each do |reasoning|
+          render_transcript_block("Reasoning", reasoning)
+        end
       end
 
       def render_assistant_message(message)
@@ -66,7 +67,7 @@ module Kward
       def render_transcript_block(label, content)
         return if content.to_s.empty?
 
-        rendered = render_markdown_transcript(content)
+        rendered = render_markdown_transcript(content).sub(/\n+\z/, "")
         if prompt_interface?
           print_block_delta(label, rendered)
           finish_stream_block
@@ -84,6 +85,9 @@ module Kward
         when Events::ReasoningDelta
           append_markdown_delta(markdown_chunks, "Reasoning", event.delta)
           :streamed
+        when Events::ReasoningBoundary
+          flush_markdown_deltas(markdown_chunks)
+          :streamed
         when Events::AssistantDelta
           append_markdown_delta(markdown_chunks, "Assistant", event.delta)
           :assistant_streamed

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/config_files.rb

@@ -129,6 +129,9 @@ module Kward
           "provider" => "auto",
           "allow_model_providers" => false
         },
+        "updates" => {
+          "check" => true
+        },
         "sessions" => {
           "auto_resume" => false
         },

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/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)

data/lib/kward/pan/index.html.erb

@@ -100,6 +100,7 @@
       currentReasoning.textContent += JSON.parse(event.data).delta;
       transcript.scrollTop = transcript.scrollHeight;
     });
+    events.addEventListener('reasoning_boundary', () => { currentReasoning = null; });
     events.addEventListener('assistant_delta', event => {
       if (!currentAssistant) currentAssistant = entry('assistant', 'Assistant', '');
       currentAssistant.textContent += JSON.parse(event.data).delta;

data/lib/kward/pan/server.rb

@@ -166,6 +166,8 @@ module Kward
         case event
         when Events::ReasoningDelta
           broadcast("reasoning_delta", { delta: event.delta.to_s })
+        when Events::ReasoningBoundary
+          broadcast("reasoning_boundary", {})
         when Events::AssistantDelta
           broadcast("assistant_delta", { delta: event.delta.to_s })
         when Events::Retry

data/lib/kward/plugin_registry.rb

@@ -454,6 +454,8 @@ module Kward
       case event.class.name
       when "Kward::Events::ReasoningDelta"
         transcript_event("reasoning_delta", delta: event.delta)
+      when "Kward::Events::ReasoningBoundary"
+        transcript_event("reasoning_boundary")
       when "Kward::Events::AssistantDelta"
         transcript_event("assistant_delta", delta: event.delta)
       when "Kward::Events::AssistantMessage"

data/lib/kward/prompt_interface/transcript_renderer.rb

@@ -15,7 +15,7 @@ module Kward
             @stream_state.start_block(label)
           end
           write_transcript_text_locked(delta) unless delta.empty?
-          write_transcript_text_locked("\n") if finish && @stream_state.block
+          write_transcript_text_locked("\n") if finish && @stream_state.block && !@transcript_buffer.end_with?("\n")
           @stream_state.finish_block if finish
           restore_composer_cursor_locked unless @restoring_transcript
         end

data/lib/kward/rpc/server.rb

@@ -426,7 +426,7 @@ module Kward
           events: {
             notification: TURN_EVENT_NOTIFICATION,
             assistantText: "assistantDelta",
-            reasoning: { start: false, delta: true, end: false },
+            reasoning: { start: false, delta: true, boundary: 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: true, result: true, normalizedMetadata: true, diffs: true, changedFiles: true, workspaceGuardrails: workspace_guardrails_enabled?, focusedContext: true, contextBudgetStats: true },

data/lib/kward/rpc/session_manager.rb

@@ -1256,6 +1256,8 @@ module Kward
         case event
         when Events::ReasoningDelta
           emit_turn_event(turn, "reasoningDelta", { delta: event.delta })
+        when Events::ReasoningBoundary
+          emit_turn_event(turn, "reasoningBoundary", {})
         when Events::AssistantDelta
           emit_turn_event(turn, "assistantDelta", { delta: event.delta })
         when Events::AssistantMessage

data/lib/kward/rpc/transcript_normalizer.rb

@@ -157,18 +157,19 @@ module Kward
       end
 
       def response_item_content(message)
-        response_items(message).filter_map do |item|
-          next unless item.is_a?(Hash)
+        response_items(message).flat_map do |item|
+          next [] unless item.is_a?(Hash)
 
           case ToolCall.value(item, :type).to_s
           when "reasoning"
-            thinking = reasoning_item_text(item)
-            { type: "thinking", thinking: thinking } unless thinking.empty?
+            reasoning_item_blocks(item).map { |thinking| { type: "thinking", thinking: thinking } }
           when "message"
-            next if ToolCall.value(item, :phase).to_s == "commentary"
+            next [] if ToolCall.value(item, :phase).to_s == "commentary"
 
             text = response_message_item_text(item)
-            { type: "text", text: text } unless text.empty?
+            text.empty? ? [] : [{ type: "text", text: text }]
+          else
+            []
           end
         end
       end
@@ -177,10 +178,9 @@ module Kward
         MessageAccess.response_items(message)
       end
 
-      def reasoning_item_text(item)
-        summary = ToolCall.value(item, :summary)
-        content = ToolCall.value(item, :content)
-        response_text_parts(summary).empty? ? response_text_parts(content).join("\n\n") : response_text_parts(summary).join("\n\n")
+      def reasoning_item_blocks(item)
+        summary = response_text_parts(ToolCall.value(item, :summary))
+        summary.empty? ? response_text_parts(ToolCall.value(item, :content)) : summary
       end
 
       def response_message_item_text(item)

data/lib/kward/update_check.rb

@@ -29,15 +29,11 @@ module Kward
       true
     end
 
-    def notice
+    def notice(refresh: false)
       return nil unless enabled?
 
-      latest_version = cache["latest_version"].to_s
-      return nil if latest_version.empty?
-      return nil if dismissed_version == latest_version
-      return nil unless newer_than_current?(latest_version)
-
-      Notice.new(latest_version: latest_version)
+      refresh_if_stale if refresh
+      notice_from_cache
     end
 
     def refresh_if_stale
@@ -69,6 +65,15 @@ module Kward
       cache["dismissed_version"].to_s
     end
 
+    def notice_from_cache
+      latest_version = cache["latest_version"].to_s
+      return nil if latest_version.empty?
+      return nil if dismissed_version == latest_version
+      return nil unless newer_than_current?(latest_version)
+
+      Notice.new(latest_version: latest_version)
+    end
+
     def stale?
       checked_at = Time.iso8601(cache["checked_at"].to_s)
       (@now - checked_at) >= CHECK_INTERVAL_SECONDS

data/lib/kward/version.rb

@@ -1,5 +1,5 @@
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # Current gem version.
-  VERSION = "0.75.0"
+  VERSION = "0.76.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kward
 version: !ruby/object:Gem::Version
-  version: 0.75.0
+  version: 0.76.0
 platform: ruby
 authors:
 - Kai Wood