kward 0.74.0 → 0.75.0

data/lib/kward/rpc/transcript_normalizer.rb

@@ -1,3 +1,4 @@
+require_relative "../message_access"
 require_relative "../tools/tool_call"
 require_relative "tool_metadata"
 
@@ -5,7 +6,7 @@ require_relative "tool_metadata"
 module Kward
   # JSON-RPC backend namespace used by UI clients.
   module RPC
-    # Normalizes Kward transcript messages into Tauren-compatible RPC payloads.
+    # Normalizes Kward transcript messages into frontend-neutral RPC payloads.
     class TranscriptNormalizer
       IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"].freeze
       THINKING_CONTENT_TYPES = ["thinking", "reasoning"].freeze
@@ -24,7 +25,7 @@ module Kward
       def normalize_message(message)
         return nil unless message.is_a?(Hash)
 
-        case ToolCall.value(message, :role).to_s
+        case MessageAccess.role(message).to_s
         when "system"
           nil
         when "user"
@@ -45,7 +46,7 @@ module Kward
       end
 
       def normalize_compaction_summary(message)
-        summary = ToolCall.value(message, :summary) || ToolCall.value(message, :content)
+        summary = MessageAccess.summary(message) || MessageAccess.content(message)
         result = { role: "compactionSummary", summary: summary.to_s }
         tokens_before = ToolCall.value(message, :tokensBefore) || ToolCall.value(message, :tokens_before)
         result[:tokensBefore] = tokens_before if tokens_before
@@ -55,12 +56,12 @@ module Kward
       def normalize_user_message(message)
         {
           role: "user",
-          content: normalize_content(ToolCall.value(message, :content))
+          content: normalize_content(MessageAccess.content(message))
         }
       end
 
       def normalize_assistant_message(message)
-        content = reasoning_first_content(normalize_content(ToolCall.value(message, :content), preserve_thinking: true))
+        content = reasoning_first_content(normalize_content(MessageAccess.content(message), preserve_thinking: true))
         content = response_item_content(message) if text_content_empty?(content)
         reasoning = normalize_reasoning_summary(message)
         content.unshift(reasoning) if reasoning && !thinking_content?(content)
@@ -83,7 +84,7 @@ module Kward
         matching_call = @tool_calls_by_id[tool_call_id]
         raw_name = ToolCall.value(message, :toolName) || ToolCall.value(message, :tool_name) || ToolCall.value(message, :name)
         tool_name = normalize_tool_name(raw_name) || raw_name || matching_call&.dig(:name)
-        content = normalize_content(ToolCall.value(message, :content))
+        content = normalize_content(MessageAccess.content(message))
 
         result = {
           role: "toolResult",
@@ -173,8 +174,7 @@ module Kward
       end
 
       def response_items(message)
-        items = ToolCall.value(message, :response_items) || ToolCall.value(message, :responseItems)
-        items.is_a?(Array) ? items : []
+        MessageAccess.response_items(message)
       end
 
       def reasoning_item_text(item)
@@ -276,8 +276,7 @@ module Kward
       end
 
       def tool_calls(message)
-        calls = ToolCall.value(message, :tool_calls) || ToolCall.value(message, :toolCalls)
-        calls.is_a?(Array) ? calls : []
+        MessageAccess.tool_calls(message)
       end
 
       def normalize_tool_name(name)

data/lib/kward/rpc/turn_context.rb

@@ -0,0 +1,109 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # JSON-RPC backend namespace used by UI clients.
+  module RPC
+    # Normalizes optional client turn context and renders it for model input.
+    class TurnContext
+      def self.normalize(context)
+        new.normalize(context)
+      end
+
+      def self.prompt(context)
+        new.prompt(context)
+      end
+
+      def normalize(context)
+        return nil if context.nil?
+        raise ArgumentError, "turn context must be an object" unless context.is_a?(Hash)
+
+        active_file = blank_to_nil(value(context, "activeFile"))
+        open_files = array_value(context, "openFiles")
+        selection = normalize_selection(value(context, "selection"))
+        diagnostics = normalize_diagnostics(value(context, "diagnostics"))
+        normalized = { active_file: active_file, open_files: open_files, selection: selection, diagnostics: diagnostics }.compact
+        normalized.empty? ? nil : normalized
+      end
+
+      def prompt(context)
+        lines = ["Additional client context:"]
+        lines << "- Active file: #{context[:active_file]}" if context[:active_file]
+        lines << "- Open files: #{context[:open_files].join(", ")}" if context[:open_files]&.any?
+        append_selection(lines, context[:selection]) if context[:selection]
+        append_diagnostics(lines, context[:diagnostics])
+        lines.join("\n")
+      end
+
+      private
+
+      def normalize_selection(selection)
+        return nil if selection.nil?
+        raise ArgumentError, "context.selection must be an object" unless selection.is_a?(Hash)
+
+        normalized = {
+          path: blank_to_nil(value(selection, "path")),
+          start_line: integer_or_nil(value(selection, "startLine")),
+          end_line: integer_or_nil(value(selection, "endLine")),
+          text: blank_to_nil(value(selection, "text"))
+        }.compact
+        normalized.empty? ? nil : normalized
+      end
+
+      def normalize_diagnostics(diagnostics)
+        return nil if diagnostics.nil?
+        raise ArgumentError, "context.diagnostics must be an array" unless diagnostics.is_a?(Array)
+
+        diagnostics.filter_map do |diagnostic|
+          next unless diagnostic.is_a?(Hash)
+
+          {
+            path: blank_to_nil(value(diagnostic, "path")),
+            line: integer_or_nil(value(diagnostic, "line")),
+            severity: blank_to_nil(value(diagnostic, "severity")),
+            message: blank_to_nil(value(diagnostic, "message"))
+          }.compact
+        end
+      end
+
+      def append_selection(lines, selection)
+        location = [selection[:path], [selection[:start_line], selection[:end_line]].compact.join("-")].compact.reject(&:empty?).join(":")
+        lines << "- Selection: #{location}" unless location.empty?
+        lines << "```\n#{selection[:text]}\n```" if selection[:text]
+      end
+
+      def append_diagnostics(lines, diagnostics)
+        Array(diagnostics).each do |diagnostic|
+          next if diagnostic.empty?
+
+          location = [diagnostic[:path], diagnostic[:line]].compact.join(":")
+          severity = diagnostic[:severity] ? "#{diagnostic[:severity]} " : ""
+          lines << "- Diagnostic: #{severity}#{location} #{diagnostic[:message]}".strip
+        end
+      end
+
+      def array_value(hash, key)
+        item = value(hash, key)
+        return nil if item.nil?
+        raise ArgumentError, "#{key} must be an array" unless item.is_a?(Array)
+
+        item.map(&:to_s).reject(&:empty?)
+      end
+
+      def integer_or_nil(item)
+        return nil if item.nil? || item.to_s.empty?
+
+        Integer(item)
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      def blank_to_nil(item)
+        item = item.to_s if item.is_a?(Symbol)
+        item.to_s.empty? ? nil : item
+      end
+
+      def value(hash, key)
+        hash[key] || hash[key.to_sym]
+      end
+    end
+  end
+end

data/lib/kward/session_store.rb

@@ -6,6 +6,7 @@ require "time"
 require_relative "config_files"
 require_relative "conversation"
 require_relative "message_access"
+require_relative "message_text"
 require_relative "private_file"
 require_relative "rpc/tool_event_normalizer"
 require_relative "tools/tool_call"
@@ -244,9 +245,9 @@ module Kward
     def create_independent_from_messages(messages, read_paths: [], provider: nil, model: nil, reasoning_effort: nil, parent_session: nil)
       session = create(provider: provider, model: model, reasoning_effort: reasoning_effort, parent_id: parent_session&.id, parent_path: parent_session&.path)
       session.rename(parent_session.name) unless parent_session&.name.to_s.strip.empty?
-      persisted = deep_copy(messages)
+      persisted = persistence_copy(messages)
       persisted.each { |message| session.append_message(message) }
-      conversation = Conversation.new(messages: deep_copy(persisted), read_paths: read_paths, workspace_root: @cwd, provider: provider, model: model, reasoning_effort: reasoning_effort)
+      conversation = Conversation.new(messages: persistence_copy(persisted), read_paths: read_paths, workspace_root: @cwd, provider: provider, model: model, reasoning_effort: reasoning_effort)
       session.attach(conversation)
       [session, conversation]
     end
@@ -851,10 +852,10 @@ module Kward
     end
 
     def persisted_messages(conversation)
-      conversation.messages.reject { |message| message_role(message) == "system" }.map { |message| deep_copy(message) }
+      conversation.messages.reject { |message| message_role(message) == "system" }.map { |message| persistence_copy(message) }
     end
 
-    def deep_copy(value)
+    def persistence_copy(value)
       JSON.parse(JSON.generate(value))
     end
 
@@ -907,23 +908,8 @@ module Kward
       MessageAccess.content(message)
     end
 
-    def message_display_content(message)
-      MessageAccess.display_content(message)
-    end
-
     def message_text(message)
-      return MessageAccess.summary(message).to_s.gsub(/\s+/, " ").strip.slice(0, 120) if message_role(message) == "compactionSummary"
-
-      display_content = message_display_content(message)
-      return display_content.to_s.gsub(/\s+/, " ").strip.slice(0, 120) unless display_content.nil?
-
-      content = message_content(message)
-      text = if content.is_a?(Array)
-               content.filter_map { |part| part["text"] || part[:text] }.join(" ")
-             else
-               content.to_s
-             end
-      text.gsub(/\s+/, " ").strip.slice(0, 120)
+      MessageText.preview(message)
     end
 
     def parse_time(value)

data/lib/kward/session_tree_nodes.rb

@@ -33,22 +33,6 @@ module Kward
       @roots.flat_map { |root| visible_nodes(root) }
     end
 
-    def contains_active_path?(node, active_path)
-      stack = [node]
-      seen = {}
-      until stack.empty?
-        current = stack.pop
-        next if seen[current.object_id]
-
-        seen[current.object_id] = true
-        entry_id = (current[:source]["entry"] || {})["id"].to_s
-        return true if active_path.include?(entry_id)
-
-        stack.concat(current[:children])
-      end
-      false
-    end
-
     def tool_calls
       @roots.each_with_object({}) do |root, calls|
         stack = [root]
@@ -68,13 +52,109 @@ module Kward
       end
     end
 
+    def layout_rows
+      active = active_path
+      roots = visible_roots
+      active_nodes = active_node_lookup(roots, active)
+      multiple_roots = roots.length > 1
+      result = []
+
+      stack = roots.sort_by { |root| active_nodes[root.object_id] ? 0 : 1 }.each_with_index.map do |root, index|
+        [root, multiple_roots ? 1 : 0, multiple_roots, multiple_roots, index == roots.length - 1, [], multiple_roots]
+      end.reverse
+
+      until stack.empty?
+        node, indent, just_branched, show_connector, is_last, gutters, virtual_root_child = stack.pop
+        entry = node[:source]["entry"] || {}
+        entry_id = entry["id"].to_s
+        display_indent = multiple_roots ? [indent - 1, 0].max : indent
+        show_node_connector = show_connector && !virtual_root_child
+
+        result << {
+          source: node[:source],
+          entry: entry,
+          depth: display_indent,
+          is_last: is_last,
+          gutters: gutters,
+          active_path: active.include?(entry_id),
+          prefix: self.class.tree_prefix(display_indent, gutters, show_node_connector, is_last, !node[:children].empty?)
+        }
+
+        children = node[:children].sort_by { |child| active_nodes[child.object_id] ? 0 : 1 }
+        multiple_children = children.length > 1
+        child_indent = if multiple_children
+                         indent + 1
+                       elsif just_branched && indent.positive?
+                         indent + 1
+                       else
+                         indent
+                       end
+        connector_position = [display_indent - 1, 0].max
+        child_gutters = show_node_connector ? gutters + [{ position: connector_position, show: !is_last }] : gutters
+
+        children.each_with_index.reverse_each do |child, index|
+          stack << [child, child_indent, multiple_children, multiple_children, index == children.length - 1, child_gutters, false]
+        end
+      end
+
+      result
+    end
+
+    def self.tree_prefix(display_indent, gutters, show_connector, is_last, foldable)
+      return "" if display_indent.to_i <= 0
+
+      connector_position = show_connector ? display_indent - 1 : -1
+      (0...(display_indent * 3)).map do |index|
+        level = index / 3
+        position = index % 3
+        gutter = gutters.find { |candidate| candidate[:position] == level }
+
+        if gutter
+          position.zero? && gutter[:show] ? "│" : " "
+        elsif show_connector && level == connector_position
+          if position.zero?
+            is_last ? "└" : "├"
+          elsif position == 1
+            foldable ? "⊟" : "─"
+          else
+            " "
+          end
+        else
+          " "
+        end
+      end.join
+    end
+
     def self.truncate_text(text)
-      normalized = text.to_s.gsub(/\s+/, " ").strip
-      normalized.length > 120 ? "#{normalized.slice(0, 117)}..." : normalized
+      MessageText.truncate_preview(text)
     end
 
     private
 
+    def active_node_lookup(roots, active_path)
+      active_ids = active_path.to_h { |id| [id, true] }
+      lookup = {}
+      stack = roots.map { |root| [root, false] }
+      seen = {}
+
+      until stack.empty?
+        node, visited = stack.pop
+        node_key = node.object_id
+        if visited
+          entry_id = (node[:source]["entry"] || {})["id"].to_s
+          lookup[node_key] = active_ids[entry_id] || node[:children].any? { |child| lookup[child.object_id] }
+        else
+          next if seen[node_key]
+
+          seen[node_key] = true
+          stack << [node, true]
+          node[:children].each { |child| stack << [child, false] }
+        end
+      end
+
+      lookup
+    end
+
     def visible_nodes(node)
       results = {}
       stack = [[node, false, {}]]

data/lib/kward/session_tree_renderer.rb

@@ -14,44 +14,15 @@ module Kward
 
     def items
       tree_nodes = SessionTreeNodes.new(roots: @roots, current_leaf: @current_leaf_id)
-      active_path = tree_nodes.active_path
       tool_calls_by_id = tree_nodes.tool_calls
-      visible_roots = tree_nodes.visible_roots
-      multiple_roots = visible_roots.length > 1
-      result = []
-
-      stack = visible_roots.sort_by { |root| tree_nodes.contains_active_path?(root, active_path) ? 0 : 1 }.each_with_index.map do |root, index|
-        [root, multiple_roots ? 1 : 0, multiple_roots, multiple_roots, index == visible_roots.length - 1, [], multiple_roots]
-      end.reverse
-
-      until stack.empty?
-        node, indent, just_branched, show_connector, is_last, gutters, virtual_root_child = stack.pop
-        entry = node[:source]["entry"] || {}
-        display_indent = multiple_roots ? [indent - 1, 0].max : indent
-        prefix = session_tree_visual_prefix(display_indent, gutters, show_connector && !virtual_root_child, is_last, !node[:children].empty?)
-        result << {
-          entry: entry,
-          label: session_tree_label(entry, node[:source], prefix, active_path.include?(entry["id"].to_s), tool_calls_by_id)
-        }
 
-        children = node[:children].sort_by { |child| tree_nodes.contains_active_path?(child, active_path) ? 0 : 1 }
-        multiple_children = children.length > 1
-        child_indent = if multiple_children
-                         indent + 1
-                       elsif just_branched && indent.positive?
-                         indent + 1
-                       else
-                         indent
-                       end
-        connector_position = [display_indent - 1, 0].max
-        child_gutters = show_connector && !virtual_root_child ? gutters + [{ position: connector_position, show: !is_last }] : gutters
-
-        children.each_with_index.reverse_each do |child, index|
-          stack << [child, child_indent, multiple_children, multiple_children, index == children.length - 1, child_gutters, false]
-        end
+      tree_nodes.layout_rows.map do |row|
+        prefix = row[:prefix].empty? ? "" : "      #{row[:prefix]}"
+        {
+          entry: row[:entry],
+          label: session_tree_label(row[:entry], row[:source], prefix, row[:active_path], tool_calls_by_id)
+        }
       end
-
-      result
     end
 
     private
@@ -81,32 +52,6 @@ module Kward
       end
     end
 
-    def session_tree_visual_prefix(display_indent, gutters, show_connector, is_last, foldable)
-      return "" if display_indent.to_i <= 0
-
-      connector_position = show_connector ? display_indent - 1 : -1
-      indentation = "      "
-      indentation + (0...(display_indent * 3)).map do |index|
-        level = index / 3
-        position = index % 3
-        gutter = gutters.find { |candidate| candidate[:position] == level }
-
-        if gutter
-          position.zero? && gutter[:show] ? "│" : " "
-        elsif show_connector && level == connector_position
-          if position.zero?
-            is_last ? "└" : "├"
-          elsif position == 1
-            foldable ? "⊟" : "─"
-          else
-            " "
-          end
-        else
-          " "
-        end
-      end.join
-    end
-
     def session_tree_tool_display(message, tool_calls_by_id)
       tool_call = tool_calls_by_id[session_tree_message_tool_call_id(message).to_s]
       return SessionTreeToolDisplay.label(tool_call) if tool_call

data/lib/kward/skills/registry.rb

@@ -6,8 +6,12 @@ module Kward
   module Skills
     # Parsed skill metadata and instruction path.
     class Registry
-      def initialize(config_dir:, skill_class:, max_file_bytes:, markdown_parser:, inside_directory:)
+      SkillSource = Struct.new(:root, :label, :scope, :precedence, keyword_init: true)
+
+      def initialize(config_dir:, workspace_root:, project_skills_trusted:, skill_class:, max_file_bytes:, markdown_parser:, inside_directory:)
         @config_dir = config_dir
+        @workspace_root = workspace_root
+        @project_skills_trusted = project_skills_trusted
         @skill_class = skill_class
         @max_file_bytes = max_file_bytes
         @markdown_parser = markdown_parser
@@ -15,24 +19,23 @@ module Kward
       end
 
       def skills
-        skills_root = File.join(@config_dir, "skills")
-        return [] unless Dir.exist?(skills_root)
-
         seen = {}
-        Dir.glob(File.join(skills_root, "*", "SKILL.md")).sort.filter_map do |path|
-          skill = parse_skill(path)
-          next unless skill
+        skill_sources.flat_map do |source|
+          scan_source(source).filter_map do |path|
+            skill = parse_skill(path)
+            next unless skill
 
-          if seen[skill.name]
-            warn "Warning: skipping duplicate Kward skill #{skill.name.inspect}: #{path}"
-            next
-          end
+            if seen[skill.name]
+              warn "Warning: skipping duplicate Kward skill #{skill.name.inspect}: #{path}"
+              next
+            end
 
-          seen[skill.name] = true
-          skill
+            seen[skill.name] = true
+            skill
+          end
         end
       rescue StandardError => e
-        warn "Warning: skipping Kward skills in #{skills_root}: #{e.message}"
+        warn "Warning: skipping Kward skills: #{e.message}"
         []
       end
 
@@ -54,7 +57,8 @@ module Kward
         size = File.size(real_target)
         return "Error: skill file too large: #{path} (#{size} bytes)" if size > @max_file_bytes
 
-        File.read(real_target)
+        content = File.read(real_target)
+        relative_path.to_s.empty? ? skill_content(skill, content) : content
       rescue Errno::ENOENT
         "Error: skill file not found: #{path}"
       rescue StandardError => e
@@ -63,17 +67,105 @@ module Kward
 
       private
 
+      def skill_sources
+        [
+          SkillSource.new(root: File.join(@workspace_root, ".kward", "skills"), label: "project Kward skills", scope: :project, precedence: 0),
+          SkillSource.new(root: File.join(@workspace_root, ".agents", "skills"), label: "project Agent Skills", scope: :project, precedence: 1),
+          SkillSource.new(root: File.join(@config_dir, "skills"), label: "user Kward skills", scope: :user, precedence: 2),
+          SkillSource.new(root: File.expand_path("~/.agents/skills"), label: "user Agent Skills", scope: :user, precedence: 3)
+        ]
+      end
+
+      def scan_source(source)
+        return [] unless Dir.exist?(source.root)
+        if source.scope == :project && !@project_skills_trusted
+          warn "Warning: skipping #{source.label} in #{source.root}: project skills are not trusted"
+          return []
+        end
+
+        Dir.glob(File.join(source.root, "*", "SKILL.md")).sort
+      rescue StandardError => e
+        warn "Warning: skipping #{source.label} in #{source.root}: #{e.message}"
+        []
+      end
+
+      def skill_content(skill, content)
+        lines = [
+          %(<skill_content name="#{xml_escape(skill.name)}">),
+          content,
+          "",
+          "Skill directory: #{File.realpath(skill.folder)}",
+          "Relative paths in this skill are relative to the skill directory."
+        ]
+        resources = skill_resources(skill.folder)
+        unless resources.empty?
+          lines << ""
+          lines << "<skill_resources>"
+          resources.each { |path| lines << "  <file>#{xml_escape(path)}</file>" }
+          lines << "</skill_resources>"
+        end
+        lines << "</skill_content>"
+        lines.join("\n")
+      end
+
+      def skill_resources(folder)
+        roots = %w[scripts references assets].map { |name| File.join(folder, name) }.select { |path| Dir.exist?(path) }
+        resources = roots.flat_map do |root|
+          Dir.glob(File.join(root, "**", "*"))
+        end.select { |path| File.file?(path) }.sort.first(200)
+        base = Pathname.new(folder)
+        resources.map { |path| Pathname.new(path).relative_path_from(base).to_s }
+      rescue StandardError
+        []
+      end
+
+      def xml_escape(text)
+        text.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;").gsub('"', "&quot;")
+      end
+
       def parse_skill(path)
         frontmatter, = @markdown_parser.call(path)
         name = frontmatter.fetch("name", "").to_s.strip
-        name = File.basename(File.dirname(path)) if name.empty?
         description = frontmatter.fetch("description", "").to_s.strip
+        return warn_skip(path, "missing name") if name.empty?
+        return warn_skip(path, "missing description") if description.empty?
+        return warn_skip(path, "description exceeds 1024 characters") if description.length > 1024
+
+        warn "Warning: Kward skill #{path}: name does not match parent directory" if name != File.basename(File.dirname(path))
+        warn "Warning: Kward skill #{path}: name exceeds 64 characters" if name.length > 64
+        warn "Warning: Kward skill #{path}: name contains invalid characters" unless valid_name?(name)
+
+        compatibility = optional_text(frontmatter["compatibility"])
+        warn "Warning: Kward skill #{path}: compatibility exceeds 500 characters" if compatibility && compatibility.length > 500
 
-        @skill_class.new(name: name, description: description, folder: File.dirname(path), path: path)
+        @skill_class.new(
+          name: name,
+          description: description,
+          folder: File.dirname(path),
+          path: path,
+          license: optional_text(frontmatter["license"]),
+          compatibility: compatibility,
+          metadata: frontmatter["metadata"].is_a?(Hash) ? frontmatter["metadata"] : {},
+          allowed_tools: optional_text(frontmatter["allowed-tools"])
+        )
       rescue StandardError => e
         warn "Warning: skipping Kward skill #{path}: #{e.message}"
         nil
       end
+
+      def valid_name?(name)
+        name.match?(/\A[a-z0-9]+(?:-[a-z0-9]+)*\z/)
+      end
+
+      def optional_text(value)
+        text = value.to_s.strip
+        text.empty? ? nil : text
+      end
+
+      def warn_skip(path, reason)
+        warn "Warning: skipping Kward skill #{path}: #{reason}"
+        nil
+      end
     end
   end
 end

data/lib/kward/tools/mcp_tool.rb

@@ -8,6 +8,10 @@ module Kward
     class MCPTool < Base
       attr_reader :server_name, :remote_name
 
+      def display_name
+        "#{server_name}.#{remote_name}"
+      end
+
       def initialize(server_name:, client:, tool:)
         @server_name = server_name.to_s
         @client = client

data/lib/kward/tools/read_skill.rb

@@ -8,12 +8,16 @@ module Kward
     # Tool wrapper for reading configured skill instructions.
     class ReadSkill < Base
       # Builds the tool schema and stores the execution dependency.
-      def initialize
+      def initialize(skills: nil)
+        name_property = { type: "string", description: "Skill name." }
+        skill_names = Array(skills).map(&:name).compact.sort
+        name_property[:enum] = skill_names unless skill_names.empty?
+
         super(
           "read_skill",
           "Read configured skill instructions/files.",
           properties: {
-            name: { type: "string", description: "Skill name." },
+            name: name_property,
             path: { type: "string", description: "Path inside skill; default SKILL.md." }
           },
           required: ["name"]
@@ -21,11 +25,12 @@ module Kward
       end
 
       # Executes the tool and returns model-facing output text.
-      def call(args, _conversation, cancellation: nil)
+      def call(args, conversation, cancellation: nil)
         name = argument(args, :name, "")
         path = argument(args, :path)
+        workspace_root = conversation.respond_to?(:workspace_root) ? conversation.workspace_root : Dir.pwd
 
-        ConfigFiles.read_skill_file(name, path)
+        ConfigFiles.read_skill_file(name, path, workspace_root: workspace_root)
       end
     end
   end