kward 0.74.0 → 0.76.0

data/lib/kward/hooks/manager.rb

@@ -0,0 +1,158 @@
+require_relative "../deep_copy"
+require_relative "audit_log"
+require_relative "catalog"
+require_relative "decision"
+require_relative "event"
+require_relative "matcher"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  module Hooks
+    # Dispatches lifecycle events to registered hooks and combines decisions.
+    class Manager
+      Handler = Struct.new(:id, :event, :source, :order, :match, :callback, :failure_policy, keyword_init: true)
+      Result = Struct.new(:event, :decision, :decisions, :warnings, :messages, :payload, keyword_init: true) do
+        def allowed?
+          !decision.deny? && !decision.ask?
+        end
+
+        def denied?
+          decision.deny?
+        end
+
+        def approval_required?
+          decision.ask?
+        end
+      end
+
+      attr_reader :handlers
+      attr_writer :on_result
+
+      def initialize(audit_log: AuditLog.new, on_result: nil)
+        @handlers = []
+        @audit_log = audit_log
+        @on_result = on_result
+      end
+
+      def register(event, id: nil, source: nil, order: 100, match: nil, failure_policy: nil, &callback)
+        raise ArgumentError, "Hook requires an event name" if event.to_s.empty?
+        raise ArgumentError, "Hook requires a handler" unless callback
+
+        handler = Handler.new(
+          id: id || "#{source || "hook"}:#{event}:#{@handlers.length + 1}",
+          event: event.to_s,
+          source: source,
+          order: order.to_i,
+          match: Matcher.new(match),
+          callback: callback,
+          failure_policy: Catalog.failure_policy(event, failure_policy)
+        )
+        @handlers << handler
+        handler
+      end
+
+      def empty?
+        @handlers.empty?
+      end
+
+      def run(event, context: nil)
+        event = normalize_event(event)
+        decisions = []
+        warnings = []
+        messages = []
+        payload = DeepCopy.dup(event.payload)
+
+        handlers_for(event).each do |handler|
+          decision = call_handler(handler, event, context)
+          decisions << decision
+          warnings << decision.message if decision.warning? && decision.message
+          messages << decision.message if decision.message && !decision.warning?
+
+          if decision.modify?
+            modifications = Catalog.filter_modifications(event.name, decision.payload)
+            payload = DeepCopy.merge(payload, modifications)
+            event = event_with_payload(event, payload)
+          end
+
+          break if decision.deny?
+        end
+
+        final_decision = final_decision(decisions)
+        result = Result.new(
+          event: event,
+          decision: final_decision,
+          decisions: decisions,
+          warnings: warnings,
+          messages: messages,
+          payload: payload
+        )
+        @audit_log&.log_result(event: event, result: result)
+        @on_result&.call(event, result) unless decisions.empty?
+        result
+      end
+
+      private
+
+      def normalize_event(event)
+        return event if event.is_a?(Event)
+
+        Event.new(**event)
+      end
+
+      def handlers_for(event)
+        @handlers
+          .select { |handler| handler.event == event.name && handler.match.match?(event) }
+          .sort_by { |handler| [handler.order, handler.id.to_s] }
+      end
+
+      def call_handler(handler, event, context)
+        started_at = @audit_log&.monotonic_now
+        value = if handler.callback.arity == 1
+                  handler.callback.call(event)
+                else
+                  handler.callback.call(event, context)
+                end
+        Decision.normalize(value).tap do |decision|
+          log_handler(event, handler, decision, started_at)
+        end
+      rescue StandardError => e
+        Catalog.failure_decision(
+          handler.failure_policy,
+          "Hook #{handler.id} failed: #{e.message}",
+          metadata: { hook_id: handler.id, source: handler.source }
+        ).tap do |decision|
+          log_handler(event, handler, decision, started_at)
+        end
+      end
+
+      def log_handler(event, handler, decision, started_at)
+        @audit_log&.log_handler(
+          event: event,
+          handler: handler,
+          decision: decision,
+          duration_ms: started_at ? @audit_log.duration_ms(started_at) : nil
+        )
+      end
+
+      def final_decision(decisions)
+        decisions.find(&:deny?) || decisions.find(&:ask?) || decisions.reverse.find(&:modify?) || decisions.find(&:warning?) || Decision.allow
+      end
+
+      def event_with_payload(event, payload)
+        Event.new(
+          id: event.id,
+          name: event.name,
+          phase: event.phase,
+          timestamp: event.timestamp,
+          session: event.session,
+          turn: event.turn,
+          workspace: event.workspace,
+          frontend: event.frontend,
+          agent: event.agent,
+          payload: payload
+        )
+      end
+
+    end
+  end
+end

data/lib/kward/hooks/matcher.rb

@@ -0,0 +1,75 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  module Hooks
+    # Matches lifecycle hook selectors against event payloads.
+    class Matcher
+      def initialize(match = nil)
+        @match = match || {}
+      end
+
+      def match?(event)
+        return true if @match.empty?
+
+        @match.all? { |key, expected| matches_key?(event, key.to_s, expected) }
+      end
+
+      private
+
+      def matches_key?(event, key, expected)
+        case key
+        when "event", "name"
+          matches_value?(event.name, expected)
+        when "phase"
+          matches_value?(event.phase, expected)
+        when "tool", "tool_name"
+          matches_value?(payload_value(event, "tool_name") || payload_value(event, "tool"), expected)
+        when "mcp_server", "server"
+          matches_value?(payload_value(event, "server_name") || payload_value(event, "mcp_server"), expected)
+        when "mcp_tool", "remote_name"
+          matches_value?(payload_value(event, "remote_name") || payload_value(event, "mcp_tool"), expected)
+        when "operation"
+          matches_value?(payload_value(event, "operation"), expected)
+        when "frontend"
+          matches_value?(event.frontend[:name] || event.frontend["name"], expected)
+        when "provider"
+          matches_value?(event.agent[:provider] || event.agent["provider"], expected)
+        when "model"
+          matches_value?(event.agent[:model] || event.agent["model"], expected)
+        when "path", "paths"
+          matches_path?(payload_paths(event), expected)
+        when "command_regex"
+          value = payload_value(event, "command").to_s
+          Array(expected).any? { |pattern| Regexp.new(pattern.to_s).match?(value) }
+        else
+          matches_value?(payload_value(event, key), expected)
+        end
+      end
+
+      def payload_value(event, key)
+        event.payload[key.to_sym] || event.payload[key]
+      end
+
+      def payload_paths(event)
+        values = []
+        values << payload_value(event, "path")
+        values.concat(Array(payload_value(event, "paths")))
+        Array(payload_value(event, "files")).each do |file|
+          values << (file[:path] || file["path"]) if file.respond_to?(:[])
+        end
+        values.compact.map(&:to_s)
+      end
+
+      def matches_path?(paths, expected)
+        patterns = Array(expected).map(&:to_s)
+        paths.any? do |path|
+          patterns.any? { |pattern| File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB) }
+        end
+      end
+
+      def matches_value?(actual, expected)
+        expected_values = Array(expected).map(&:to_s)
+        expected_values.include?(actual.to_s)
+      end
+    end
+  end
+end

data/lib/kward/hooks.rb

@@ -0,0 +1,16 @@
+require_relative "hooks/audit_log"
+require_relative "hooks/catalog"
+require_relative "hooks/decision"
+require_relative "hooks/event"
+require_relative "hooks/matcher"
+require_relative "hooks/manager"
+require_relative "hooks/command_handler"
+require_relative "hooks/http_handler"
+require_relative "hooks/config_loader"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Lifecycle hook primitives and dispatch helpers.
+  module Hooks
+  end
+end

data/lib/kward/markdown_transcript.rb

@@ -1,4 +1,5 @@
 require_relative "message_access"
+require_relative "message_text"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -37,10 +38,10 @@ module Kward
     end
 
     def message_display_text(message)
-      display_content = MessageAccess.value(message, :display_content) || MessageAccess.value(message, :displayContent)
-      return display_content.to_s unless display_content.nil?
+      return MessageText.full_text(message) unless MessageAccess.display_content(message).nil?
 
-      markdown_content(MessageAccess.content(message))
+      content = MessageAccess.content(message)
+      content.is_a?(Array) ? markdown_content(content) : MessageText.full_text(message)
     end
 
     def markdown_content(content)

data/lib/kward/mcp/client.rb

@@ -8,7 +8,7 @@ module Kward
 
     # Minimal MCP client for discovering and invoking server tools.
     class Client
-      attr_reader :name
+      attr_reader :name, :transport
 
       def initialize(name:, transport:)
         @name = name.to_s

data/lib/kward/mcp/server_config.rb

@@ -11,13 +11,17 @@ module Kward
       module_function
 
       def clients_from_config(config)
-        servers = ConfigFiles.mcp_servers(config)
-
-        servers.filter_map do |name, settings|
+        configured_servers(config).filter_map do |name, settings|
           client_from_settings(name, settings)
         end
       end
 
+      def configured_servers(config)
+        ConfigFiles.mcp_servers(config).select do |_name, settings|
+          settings.is_a?(Hash) && settings["enabled"] != false
+        end
+      end
+
       def client_from_settings(name, settings)
         return nil unless settings.is_a?(Hash)
         return nil if settings["enabled"] == false

data/lib/kward/mcp/stdio_transport.rb

@@ -10,6 +10,8 @@ module Kward
     class StdioTransport
       DEFAULT_TIMEOUT_SECONDS = 10
 
+      attr_reader :command
+
       def initialize(command:, args: [], env: {}, timeout_seconds: DEFAULT_TIMEOUT_SECONDS)
         @command = command.to_s
         @args = Array(args).map(&:to_s)
@@ -62,7 +64,11 @@ module Kward
         raise ArgumentError, "MCP server command is required" if @command.empty?
 
         @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(@env, @command, *@args)
-        @stderr_thread = Thread.new { @stderr.each_line { |_line| } }
+        @stderr_thread = Thread.new do
+          @stderr.each_line { |_line| }
+        rescue IOError
+          nil
+        end
         @started = true
       rescue SystemCallError => e
         raise "Failed to start MCP server #{@command}: #{e.message}"

data/lib/kward/memory/turn_context.rb

@@ -0,0 +1,19 @@
+require_relative "manager"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  module Memory
+    # Applies retrieved memory context to a conversation before a model turn.
+    module TurnContext
+      module_function
+
+      def apply(conversation:, input:, manager: Manager.new)
+        retrieval = manager.retrieve_relevant(input: input, workspace_root: conversation.workspace_root)
+        conversation.last_memory_retrieval = retrieval
+        conversation.memory_context = manager.memory_block(retrieval)
+        conversation.refresh_system_message!
+        retrieval
+      end
+    end
+  end
+end

data/lib/kward/message_access.rb

@@ -5,8 +5,8 @@ module Kward
   # Kward stores transcript entries as plain hashes because model payloads,
   # JSONL sessions, plugins, and RPC normalizers all need to pass them around
   # without framework objects. Restored sessions may contain either symbol keys,
-  # string keys, or Tauren-style camelCase aliases. `MessageAccess` centralizes
-  # those lookup rules so callers do not grow one-off compatibility branches.
+  # string keys, or camelCase aliases. `MessageAccess` centralizes those lookup
+  # rules so callers do not grow one-off compatibility branches.
   module MessageAccess
     module_function
 

data/lib/kward/message_text.rb

@@ -28,6 +28,20 @@ module Kward
       content_text(MessageAccess.content(message)).strip
     end
 
+    # Returns compact one-line text for session tree and list previews.
+    #
+    # @param message [Hash] persisted conversation message
+    # @param length [Integer] maximum preview length
+    # @return [String] whitespace-normalized text, truncated with ellipsis
+    def preview(message, length: 120)
+      text = if MessageAccess.role(message) == "compactionSummary"
+               MessageAccess.summary(message).to_s
+             else
+               full_text(message)
+             end
+      truncate_preview(text, length: length)
+    end
+
     # Converts message content into plain text without applying display-content
     # overrides.
     #
@@ -41,5 +55,10 @@ module Kward
         content.to_s
       end
     end
+
+    def truncate_preview(text, length: 120)
+      normalized = text.to_s.gsub(/\s+/, " ").strip
+      normalized.length > length ? "#{normalized.slice(0, length - 3)}..." : normalized
+    end
   end
 end

data/lib/kward/model/client.rb

@@ -8,6 +8,7 @@ require_relative "../cancellation"
 require_relative "../config_files"
 require_relative "../openrouter_model_cache"
 require_relative "context_overflow"
+require_relative "copilot_models"
 require_relative "model_info"
 require_relative "payloads"
 require_relative "../telemetry/logger"
@@ -93,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)
@@ -125,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
@@ -227,8 +229,8 @@ module Kward
     end
 
     # Projects messages/tools into the provider-specific context shape without sending it.
-    def current_context_parts(messages, tools)
-      build_context_parts(current_provider, messages, tools)
+    def current_context_parts(messages, tools, provider: current_provider, model: nil)
+      build_context_parts(ModelInfo.provider_label(provider), messages, tools, model: model)
     end
 
     # Returns whether the active provider can accept steering while a turn is streaming.
@@ -256,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(
@@ -268,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
@@ -305,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,
@@ -314,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
@@ -525,30 +529,15 @@ module Kward
       live_models = fetch_copilot_models
       return static_copilot_model_choices if live_models.empty?
 
-      supported_copilot_model_choices(live_models)
+      CopilotModels.supported_choices(live_models)
     end
 
     def static_copilot_model_choices
-      supported_copilot_model_choices(ModelInfo::COPILOT_MODEL_CHOICES)
-    end
-
-    def supported_copilot_model_choices(choices)
-      choices.select { |model| copilot_supported_model?(model) }.uniq
+      CopilotModels.supported_choices(ModelInfo::COPILOT_MODEL_CHOICES)
     end
 
     def resolved_copilot_chat_model(configured_model)
-      choices = fetch_copilot_models
-      return configured_model if choices.empty? || choices.include?(configured_model)
-
-      supported = choices.find { |model| copilot_supported_model?(model) }
-      raise "No Copilot models supported by Kward are available for this account. Kward currently supports Copilot GPT-5 Responses and Gemini/GPT-4.1 chat models." unless supported
-
-      supported
-    end
-
-    def copilot_supported_model?(model)
-      text = model.to_s
-      copilot_responses_model?(text) || text.match?(/\A(?:gemini-|gpt-4\.1|oswe-)/)
+      CopilotModels.resolved_chat_model(configured_model, fetch_copilot_models)
     end
 
     def fetch_copilot_models
@@ -566,33 +555,11 @@ module Kward
       response = Net::HTTP.start(url.hostname, url.port, use_ssl: true) { |http| http.request(request) }
       return [] unless response.is_a?(Net::HTTPSuccess)
 
-      @copilot_models = parse_copilot_models(response.body)
+      @copilot_models = CopilotModels.parse(response.body)
     rescue StandardError
       []
     end
 
-    def parse_copilot_models(body)
-      model_catalog_entries(body).filter_map do |entry|
-        copilot_model_id(entry)
-      end.uniq
-    rescue JSON::ParserError
-      []
-    end
-
-    def model_catalog_entries(body)
-      data = JSON.parse(body.to_s)
-      entries = data.is_a?(Hash) ? data["data"] || data["models"] || data["items"] || [] : data
-      Array(entries)
-    end
-
-    def copilot_model_id(entry)
-      return entry.to_s.strip unless entry.is_a?(Hash)
-      return nil if entry.key?("model_picker_enabled") && entry["model_picker_enabled"] == false
-
-      id = entry["id"] || entry["model"] || entry["name"]
-      id.to_s.strip unless id.to_s.strip.empty?
-    end
-
     def copilot_responses_payload(messages, tools, max_tokens: nil, model: nil, reasoning: nil)
       parts = build_context_parts("CopilotResponses", messages, tools, model: model)
       payload = {
@@ -685,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
@@ -705,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
 
@@ -717,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, 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, 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)
@@ -871,6 +838,10 @@ module Kward
       ConfigFiles.config_value(@config, *keys)
     end
 
+    def codex_show_raw_reasoning?
+      @config["codex_show_raw_reasoning"] == true
+    end
+
     def load_config
       ConfigFiles.read_config(@config_path)
     end

data/lib/kward/model/context_usage.rb

@@ -80,6 +80,10 @@ module Kward
 
   # Structured context usage result returned to frontends.
   class TiktokenTokenCounter
+    def initialize
+      @encodings = {}
+    end
+
     def count(text, model:)
       text = text.to_s
       tokenizer = encoding(model)
@@ -93,11 +97,13 @@ module Kward
     private
 
     def encoding(model)
-      require "tiktoken_ruby"
+      @encodings[model.to_s] ||= begin
+        require "tiktoken_ruby"
 
-      Tiktoken.encoding_for_model(model.to_s) || Tiktoken.get_encoding(encoding_name_for_model(model))
-    rescue StandardError
-      Tiktoken.get_encoding(encoding_name_for_model(model)) if defined?(Tiktoken)
+        Tiktoken.encoding_for_model(model.to_s) || Tiktoken.get_encoding(encoding_name_for_model(model))
+      rescue StandardError
+        Tiktoken.get_encoding(encoding_name_for_model(model)) if defined?(Tiktoken)
+      end
     end
 
     def rough_count(text)

data/lib/kward/model/copilot_models.rb

@@ -0,0 +1,44 @@
+require "json"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Parses and filters GitHub Copilot model catalog responses.
+  module CopilotModels
+    module_function
+
+    def parse(body)
+      catalog_entries(body).filter_map { |entry| model_id(entry) }.uniq
+    rescue JSON::ParserError
+      []
+    end
+
+    def supported?(model)
+      text = model.to_s
+      text.match?(/\Agpt-5(?:\.|-|\z)/) || text.match?(/\A(?:gemini-|gpt-4\.1|oswe-)/)
+    end
+
+    def supported_choices(choices)
+      choices.select { |model| supported?(model) }.uniq
+    end
+
+    def resolved_chat_model(configured_model, choices)
+      return configured_model if choices.empty? || choices.include?(configured_model)
+
+      choices.find { |model| supported?(model) } || raise("No Copilot models supported by Kward are available for this account. Kward currently supports Copilot GPT-5 Responses and Gemini/GPT-4.1 chat models.")
+    end
+
+    def catalog_entries(body)
+      data = JSON.parse(body.to_s)
+      entries = data.is_a?(Hash) ? data["data"] || data["models"] || data["items"] || [] : data
+      Array(entries)
+    end
+
+    def model_id(entry)
+      return entry.to_s.strip unless entry.is_a?(Hash)
+      return nil if entry.key?("model_picker_enabled") && entry["model_picker_enabled"] == false
+
+      id = entry["id"] || entry["model"] || entry["name"]
+      id.to_s.strip unless id.to_s.strip.empty?
+    end
+  end
+end