kward 0.74.0 → 0.76.0

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|-)/)
 
@@ -412,6 +421,30 @@ module Kward
       }.compact
     end
 
+    def normalize_available(models, current_provider:, current_model:, current_reasoning_effort: nil)
+      Array(models).map do |model|
+        normalize(
+          model,
+          current_provider: current_provider,
+          current_model: current_model,
+          current_reasoning_effort: current_reasoning_effort
+        )
+      end
+    end
+
+    def current_payload(provider:, model:, reasoning_effort: nil, context_window: nil)
+      normalize(
+        {
+          provider: provider,
+          id: model,
+          model: model,
+          reasoningEffort: reasoning_effort,
+          contextWindow: context_window,
+          current: true
+        }
+      )
+    end
+
     def boolean_value(value, default: false)
       return default if value.nil?
       return value if value == true || value == false

data/lib/kward/model/payloads.rb

@@ -188,14 +188,12 @@ module Kward
           text = plain_content(content).to_s
           blocks << { type: "text", text: text } unless text.empty?
           MessageAccess.tool_calls(message).each do |tool_call|
-            function = tool_call[:function] || tool_call["function"] || {}
-            name = function[:name] || function["name"]
-            arguments = function[:arguments] || function["arguments"] || "{}"
+            name = ToolCall.name(tool_call)
             blocks << {
               type: "tool_use",
-              id: normalize_anthropic_tool_call_id(tool_call[:id] || tool_call["id"] || "call_#{name}"),
+              id: normalize_anthropic_tool_call_id(ToolCall.id(tool_call) || "call_#{name}"),
               name: claude_code_tool_name(name),
-              input: parse_tool_arguments(arguments)
+              input: parse_tool_arguments(ToolCall.raw_arguments(tool_call) || "{}")
             }
           end
           output << { role: "assistant", content: blocks } unless blocks.empty?
@@ -260,11 +258,11 @@ module Kward
     end
 
     def anthropic_tool_schema(tool)
-      function = tool[:function] || tool["function"] || {}
-      schema = function[:parameters] || function["parameters"] || {}
+      function = ToolCall.function(tool)
+      schema = ToolCall.value(function, :parameters) || {}
       {
-        name: claude_code_tool_name(function[:name] || function["name"]),
-        description: function[:description] || function["description"] || "",
+        name: claude_code_tool_name(ToolCall.value(function, :name)),
+        description: ToolCall.value(function, :description) || "",
         input_schema: {
           type: "object",
           properties: schema[:properties] || schema["properties"] || {},
@@ -296,12 +294,12 @@ module Kward
             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"] || {}
+              name = ToolCall.name(tool_call)
               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"] || "{}"
+                call_id: ToolCall.id(tool_call) || name || "tool-call",
+                name: name,
+                arguments: ToolCall.raw_arguments(tool_call) || "{}"
               }
             end
           else
@@ -420,12 +418,12 @@ module Kward
     end
 
     def codex_tool_schema(tool)
-      function = tool[:function] || tool["function"] || {}
+      function = ToolCall.function(tool)
       {
         type: "function",
-        name: function[:name] || function["name"],
-        description: function[:description] || function["description"] || "",
-        parameters: function[:parameters] || function["parameters"] || {},
+        name: ToolCall.value(function, :name),
+        description: ToolCall.value(function, :description) || "",
+        parameters: ToolCall.value(function, :parameters) || {},
         strict: false
       }
     end

data/lib/kward/model/stream_parser.rb

@@ -45,11 +45,12 @@ module Kward
       raise "Copilot returned invalid SSE JSON: #{e.message}"
     end
 
-    def parse_codex_sse(body, on_reasoning_delta: nil, on_assistant_delta: nil, usage_normalizer: nil, request_error_class: nil)
-      state = codex_sse_state
+    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)
     rescue JSON::ParserError => e
       raise "Codex OAuth returned invalid SSE JSON: #{e.message}"
@@ -60,8 +61,8 @@ 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, usage_normalizer: nil, request_error_class: nil)
-      state = codex_sse_state
+    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 = +""
 
       response.read_body do |chunk|
@@ -71,11 +72,12 @@ 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
       raise "Codex OAuth returned invalid SSE JSON: #{e.message}"
@@ -218,22 +220,26 @@ module Kward
       end
     end
 
-    def codex_sse_state
+    def codex_sse_state(show_raw_reasoning: false)
       {
         content: +"",
         raw_content: +"",
         emitted_message_keys: [],
         reasoning_summary: +"",
+        raw_reasoning_visible: +"",
+        pending_reasoning_delta: +"",
+        show_raw_reasoning: show_raw_reasoning,
         tool_calls: [],
         response_item_keys: [],
         items_by_id: {},
         active_item_id: nil,
         current_text_content_part: nil,
+        current_reasoning_content_part: nil,
         usage: nil
       }
     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]"
 
@@ -250,9 +256,11 @@ 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_reasoning_delta(state, event["delta"], on_reasoning_delta: on_reasoning_delta)
+        codex_raw_reasoning_delta(state, event["delta"], on_reasoning_delta: on_reasoning_delta)
+      when "response.reasoning_text.done"
+        codex_raw_reasoning_done(state, event["text"], on_reasoning_delta: on_reasoning_delta)
       when "response.function_call_arguments.delta", "response.custom_tool_call_input.delta"
         codex_tool_arguments_delta(state, event["delta"])
       when "response.function_call_arguments.done"
@@ -299,6 +307,7 @@ module Kward
       remember_codex_item(state, item)
       state[:active_item_id] = codex_item_key(item)
       state[:current_text_content_part] = nil
+      state[:current_reasoning_content_part] = nil
     end
 
     def codex_content_part_added(state, part)
@@ -333,12 +342,71 @@ module Kward
 
       item["summary"] ||= []
       item["summary"] << deep_dup_hash(part)
+      state[:current_reasoning_content_part] = nil
     end
 
     def codex_reasoning_delta(state, delta, on_reasoning_delta: nil)
+      text = visible_codex_reasoning_delta(state, delta)
+      return if text.empty?
+
+      append_codex_reasoning_text(state, text, on_reasoning_delta: on_reasoning_delta)
+    end
+
+    def codex_raw_reasoning_delta(state, delta, on_reasoning_delta: nil)
       text = delta.to_s
       return if text.empty?
 
+      item = active_codex_item(state)
+      if item&.fetch("type", nil) == "reasoning" && state[:show_raw_reasoning]
+        item["content"] ||= [{ "type" => "reasoning_text", "text" => +"" }]
+        part = state[:current_reasoning_content_part] || item["content"].last
+        part = item["content"].last unless part.is_a?(Hash)
+        part["type"] ||= "reasoning_text"
+        part["text"] = part["text"].to_s + text
+        state[:current_reasoning_content_part] = part
+      end
+      return unless state[:show_raw_reasoning]
+
+      visible = visible_codex_reasoning_delta(state, text)
+      append_codex_raw_reasoning_text(state, visible, on_reasoning_delta: on_reasoning_delta) unless visible.empty?
+    end
+
+    def codex_raw_reasoning_done(state, text, on_reasoning_delta: nil)
+      item = active_codex_item(state)
+      full_text = text.to_s
+      if item&.fetch("type", nil) == "reasoning" && state[:show_raw_reasoning]
+        item["content"] ||= [{ "type" => "reasoning_text", "text" => +"" }]
+        part = state[:current_reasoning_content_part] || item["content"].last
+        part = item["content"].last unless part.is_a?(Hash)
+        part["type"] ||= "reasoning_text"
+        part["text"] = full_text
+        state[:current_reasoning_content_part] = part
+      end
+      return unless state[:show_raw_reasoning]
+
+      flush_codex_reasoning_delta(state, on_reasoning_delta: on_reasoning_delta)
+      visible = sanitize_codex_reasoning_text(full_text)
+      emitted = state[:raw_reasoning_visible]
+      text = visible.start_with?(emitted) ? visible[emitted.length..].to_s : (emitted.empty? ? visible : +"")
+      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, 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)
+      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)
+      text = compact_codex_reasoning_delta_spacing(state[:reasoning_summary], text)
+      return if text.empty?
+
       item = active_codex_item(state)
       if item&.fetch("type", nil) == "reasoning"
         item["summary"] ||= []
@@ -349,17 +417,76 @@ module Kward
       on_reasoning_delta&.call(text)
     end
 
-    def codex_reasoning_part_done(state, on_reasoning_delta: nil)
-      item = active_codex_item(state)
-      return unless item&.fetch("type", nil) == "reasoning"
-      return if item["summary"].to_a.empty?
+    def append_codex_raw_reasoning_text(state, text, on_reasoning_delta: nil)
+      text = compact_codex_reasoning_delta_spacing(state[:reasoning_summary], text)
+      return if text.empty?
 
-      text = "\n\n"
-      item["summary"].last["text"] = item["summary"].last["text"].to_s + text
+      state[:raw_reasoning_visible] << text
       state[:reasoning_summary] << text
       on_reasoning_delta&.call(text)
     end
 
+    def visible_codex_reasoning_delta(state, delta)
+      state[:pending_reasoning_delta] << delta.to_s
+      sanitized = sanitize_codex_reasoning_text(state[:pending_reasoning_delta], keep_incomplete_comment: true)
+      text, pending_prefix = split_trailing_comment_prefix(sanitized[:text])
+      state[:pending_reasoning_delta].replace(pending_prefix + sanitized[:pending])
+      text
+    end
+
+    def flush_codex_reasoning_delta(state, on_reasoning_delta: nil)
+      pending = state[:pending_reasoning_delta].to_s
+      state[:pending_reasoning_delta].clear
+      text = sanitize_codex_reasoning_text(pending)
+      append_codex_raw_reasoning_text(state, text, on_reasoning_delta: on_reasoning_delta) unless text.empty?
+    end
+
+    def split_trailing_comment_prefix(text)
+      string = text.to_s
+      prefix = ["<!-", "<!", "<"].find { |candidate| string.end_with?(candidate) }
+      return [string, +""] unless prefix
+
+      [string[0...-prefix.length], prefix.dup]
+    end
+
+    def sanitize_codex_reasoning_text(text, keep_incomplete_comment: false)
+      string = text.to_s
+      visible = +""
+      index = 0
+
+      while (start_index = string.index("<!--", index))
+        end_index = string.index("-->", start_index + 4)
+        if end_index
+          visible << string[index...start_index]
+          index = end_index + 3
+        elsif keep_incomplete_comment
+          visible << string[index...start_index]
+          return { text: visible, pending: string[start_index..] }
+        else
+          visible << string[index..]
+          index = string.length
+        end
+      end
+
+      visible << string[index..].to_s
+      visible = compact_blank_codex_reasoning_lines(visible)
+      keep_incomplete_comment ? { text: visible, pending: +"" } : visible
+    end
+
+    def compact_blank_codex_reasoning_lines(text)
+      text.to_s.gsub(/(?:[ \t]*\n){3,}/, "\n\n")
+    end
+
+    def compact_codex_reasoning_delta_spacing(existing, text)
+      text = compact_blank_codex_reasoning_lines(text)
+      trailing_newlines = existing.to_s[/\n+\z/].to_s.length
+      leading_newlines = text[/\A\n+/].to_s.length
+      excess_newlines = trailing_newlines + leading_newlines - 2
+      return text unless excess_newlines.positive? && leading_newlines.positive?
+
+      text[[excess_newlines, leading_newlines].min..].to_s
+    end
+
     def codex_tool_arguments_delta(state, delta)
       item = active_codex_item(state)
       return unless item && ["function_call", "custom_tool_call"].include?(item["type"])
@@ -379,10 +506,40 @@ module Kward
       return unless item.is_a?(Hash)
 
       item = merge_codex_item(active_or_known_codex_item(state, item), item)
+      item = codex_visible_reasoning_item(state, item)
       remember_codex_item(state, item)
       collect_codex_item_output(state, item, on_assistant_delta: on_assistant_delta, on_reasoning_delta: on_reasoning_delta)
       state[:active_item_id] = nil if state[:active_item_id] == codex_item_key(item)
       state[:current_text_content_part] = nil
+      state[:current_reasoning_content_part] = nil
+    end
+
+    def codex_visible_reasoning_item(state, item)
+      return item unless item.is_a?(Hash) && item["type"] == "reasoning"
+
+      visible = deep_dup_hash(item)
+      sanitize_codex_reasoning_summary_item(visible)
+      visible.delete("content") unless state[:show_raw_reasoning]
+      return visible unless state[:show_raw_reasoning]
+      return visible if visible["summary"].is_a?(Array) && !visible["summary"].empty?
+
+      text = sanitize_codex_reasoning_text(raw_reasoning_from_codex_items([visible]))
+      visible["summary"] = [{ "type" => "summary_text", "text" => text }] unless text.empty?
+      visible
+    end
+
+    def sanitize_codex_reasoning_summary_item(item)
+      return unless item["summary"].is_a?(Array)
+
+      pending = +""
+      item["summary"].each do |part|
+        next unless part.is_a?(Hash) && part.key?("text")
+
+        pending << part["text"].to_s
+        sanitized = sanitize_codex_reasoning_text(pending, keep_incomplete_comment: true)
+        part["text"] = sanitized[:text]
+        pending.replace(sanitized[:pending])
+      end
     end
 
     def collect_codex_item_output(state, item, on_assistant_delta: nil, on_reasoning_delta: nil)
@@ -398,7 +555,7 @@ module Kward
           state[:emitted_message_keys] << key
         end
       when "reasoning"
-        text = reasoning_summary_from_codex_items([item])
+        text = sanitize_codex_reasoning_text(reasoning_summary_from_codex_items([item]))
         if state[:reasoning_summary].empty? && !text.empty?
           state[:reasoning_summary] << text
           on_reasoning_delta&.call(text)
@@ -563,5 +720,13 @@ module Kward
         end
       end.join
     end
+
+    def raw_reasoning_from_codex_items(items)
+      items.flat_map do |item|
+        next [] unless item.is_a?(Hash) && item["type"] == "reasoning" && item["content"].is_a?(Array)
+
+        item["content"].filter_map { |part| part["text"] if part.is_a?(Hash) && part["type"] == "reasoning_text" }
+      end.join
+    end
   end
 end

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

@@ -9,6 +9,8 @@ require_relative "../agent"
 require_relative "../config_files"
 require_relative "../events"
 require_relative "../model/retry_message"
+require_relative "../plugin_registry"
+require_relative "../prompts/commands"
 require_relative "../rpc/transcript_normalizer"
 require_relative "../session_store"
 require_relative "../tools/tool_call"
@@ -42,10 +44,14 @@ module Kward
         reasoning_effort: (@client.current_reasoning_effort if @client.respond_to?(:current_reasoning_effort))
       )
       @session.attach(@conversation)
+      hook_context = lifecycle_hook_context
+      hook_manager = lifecycle_hook_manager
       @agent = Agent.new(
         client: @client,
-        tool_registry: ToolRegistry.new(workspace: @workspace, ask_user_question_enabled: false),
-        conversation: @conversation
+        tool_registry: ToolRegistry.new(workspace: @workspace, ask_user_question_enabled: false, hook_manager: hook_manager, hook_context: hook_context),
+        conversation: @conversation,
+        hook_manager: hook_manager,
+        hook_context: hook_context
       )
       @prompt_queue = Queue.new
       @subscribers = []
@@ -97,6 +103,49 @@ module Kward
 
     private
 
+    def lifecycle_hook_manager
+      manager = Hooks::ConfigLoader.new(ConfigFiles.lifecycle_hooks_config(@workspace.root)).manager
+      manager.on_result = method(:broadcast_lifecycle_hook_event)
+      plugin_registry.hook_handlers.each do |hook|
+        manager.register(hook.event, id: hook.id, source: hook.path, order: hook.order, match: hook.match, failure_policy: hook.failure_policy) do |event, context|
+          hook.handler.call(event, context)
+        end
+      end
+      manager
+    end
+
+    def broadcast_lifecycle_hook_event(event, result)
+      broadcast("hook_event", {
+        event: {
+          id: event.id,
+          name: event.name,
+          phase: event.phase,
+          timestamp: event.timestamp.iso8601,
+          payloadKeys: event.payload.keys.map(&:to_s).sort
+        },
+        result: {
+          decision: result.decision.decision,
+          warnings: result.warnings,
+          messages: result.messages,
+          decisionCount: result.decisions.length
+        }
+      })
+    end
+
+    def lifecycle_hook_context
+      PluginRegistry::Context.new(
+        conversation: @conversation,
+        args: "",
+        session: @session,
+        workspace_root: @workspace.root.to_s,
+        say_callback: lambda { |message| broadcast("hook_message", { message: message.to_s }) }
+      )
+    end
+
+    def plugin_registry
+      @plugin_registry ||= PluginRegistry.load(reserved_commands: PromptCommands::BUILTIN_RESERVED_COMMAND_NAMES)
+    end
+
     def start_worker
       return if @worker_started
 
@@ -117,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/path_guard.rb

@@ -0,0 +1,13 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Shared path containment predicate for local filesystem guardrails.
+  module PathGuard
+    module_function
+
+    def inside?(path, root)
+      path = path.to_s
+      root = root.to_s
+      path == root || path.start_with?(root + File::SEPARATOR)
+    end
+  end
+end