kward 0.80.0 → 0.81.0

data/lib/kward/cli/runtime_helpers.rb

@@ -4,10 +4,21 @@ module Kward
   class CLI
     # Shared runtime construction helpers for CLI conversations, workspaces, plugins, and sessions.
     module RuntimeHelpers
+      MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES = 1_048_576
+      UNSAFE_TRANSCRIPT_CONTROL_PATTERN = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/.freeze
+      FROZEN_COMPOSER_COMMANDS = /\Agit\s+(?:fetch|ls-remote|push|remote|status)(?:\s|\z)/.freeze
+
       private
 
       def new_conversation(workspace_root: current_workspace_root)
-        Conversation.new(workspace_root: workspace_root, provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort, plugin_registry: plugin_registry)
+        Conversation.new(
+          workspace_root: workspace_root,
+          provider: current_model_provider,
+          model: current_model_id,
+          reasoning_effort: current_reasoning_effort,
+          plugin_registry: plugin_registry,
+          project_skill_paths: project_skill_paths_for(workspace_root)
+        )
       end
 
       def update_assistant_prompt(conversation)
@@ -50,6 +61,7 @@ module Kward
         tool_registry = ToolRegistry.new(
           workspace: workspace,
           prompt: @prompt,
+          skills: ConfigFiles.skills(workspace_root: conversation.workspace_root, project_skill_paths: project_skill_paths_for(conversation.workspace_root)),
           tool_approval: interactive_tool_approval_callback,
           hook_manager: hook_manager,
           hook_context: hook_context
@@ -60,6 +72,7 @@ module Kward
           client: @client,
           tool_registry: tool_registry,
           conversation: conversation,
+          warning_sink: ConfigFiles.warning_sink,
           hook_manager: hook_manager,
           hook_context: hook_context
         )
@@ -85,17 +98,90 @@ module Kward
           return true
         end
 
+        shell = bang_shell(agent)
+        editor_result = shell.editor_command_result(command)
+        if editor_result
+          @prompt.say(editor_result.output) unless editor_result.output.to_s.empty?
+          open_ekwsh_editor(editor_result.open_editor_path, shell) if editor_result.open_editor_path
+          return true
+        end
+
+        expanded_command = shell.expand_alias(command, interactive: true)
+        run_user_interactive_pty_command(
+          expanded_command,
+          shell: Ekwsh::DEFAULT_SHELL,
+          env: interactive_pty_environment({}, preserve_git_pager: true),
+          cwd: interactive_workspace_root(agent),
+          intro: "$ #{command}\n"
+        )
+        true
+      end
+
+      def run_captured_shell_command(command, agent)
+        command = command.to_s.strip
+        if command.empty?
+          runtime_output("Usage: /capture <command>")
+          return
+        end
+
         run_busy_local_command_and_requeue(activity: "running") do
-          result = configured_workspace(root: interactive_workspace_root(agent)).run_shell_command(command)
+          result = Workspace.new(root: interactive_workspace_root(agent)).run_shell_command(command)
           @prompt.say("\n#{colored("Shell>", :cyan, :bold)} #{command}\n#{result}\n")
         end
-        true
       end
 
       def shell_command_input?(input)
         input.to_s.start_with?("!")
       end
 
+      def complete_bang_command(input, cursor, agent)
+        value = input.to_s
+        return false unless value.start_with?("!")
+        return nil if cursor.to_i <= 1
+
+        completion = bang_shell(agent).complete(value[1..], cursor.to_i - 1)
+        return nil unless completion
+
+        Ekwsh::Completion.new(
+          range: (completion.range.begin + 1)...(completion.range.end + 1),
+          replacement: completion.replacement,
+          candidates: completion.candidates
+        )
+      end
+
+      def bang_shell(agent)
+        root = File.expand_path(interactive_workspace_root(agent).to_s)
+        aliases = ConfigFiles.read_ekwsh_config[:aliases]
+        cache_key = [root, ENV.fetch("PATH", ""), aliases.sort]
+        return @bang_shell if @bang_shell_key == cache_key
+
+        @bang_shell_key = cache_key
+        @bang_shell = Ekwsh.new(cwd: root, env: ENV.to_h, aliases: aliases)
+      end
+
+      def install_bang_completion_provider(agent)
+        return unless @prompt.respond_to?(:update_completion_provider)
+
+        @bang_completion_provider_installed = true
+        provider = lambda do |input, cursor|
+          current_agent = if respond_to?(:active_tab, true) && active_tab&.agent
+            active_tab.agent
+          else
+            agent
+          end
+          complete_bang_command(input, cursor, current_agent)
+        end
+        @prompt.update_completion_provider(provider)
+      end
+
+      def clear_bang_completion_provider
+        return unless @bang_completion_provider_installed
+        return unless @prompt.respond_to?(:update_completion_provider)
+
+        @prompt.update_completion_provider(nil)
+        @bang_completion_provider_installed = false
+      end
+
       def run_ekwsh(agent)
         unless @prompt.respond_to?(:ask)
           runtime_output("The embedded shell is only available in interactive mode.")
@@ -139,29 +225,82 @@ module Kward
         end
 
         config = ConfigFiles.read_ekwsh_config
-        env = interactive_pty_environment(config[:env])
-        cwd = interactive_workspace_root(agent)
-        @prompt.say("$ #{command}\n[interactive PTY session started]\n") if @prompt.respond_to?(:say)
-        result = run_interactive_pty_with_terminal_handoff(config[:shell], command, env: env, cwd: cwd)
-        @prompt.say("[interactive PTY session exited with status #{result.exit_status}]\n") if @prompt.respond_to?(:say)
+        run_user_interactive_pty_command(
+          command,
+          shell: config[:shell],
+          env: interactive_pty_environment(config[:env]),
+          cwd: interactive_workspace_root(agent)
+        )
+      end
+
+      def run_user_interactive_pty_command(command, shell:, env:, cwd:, intro: nil)
+        intro_message = intro || "$ #{command}\n"
+        if @prompt.respond_to?(:write_transcript)
+          @prompt.write_transcript(intro_message)
+        elsif @prompt.respond_to?(:say)
+          @prompt.say(intro_message)
+        end
+        output = +"".b
+        output_truncated = false
+        handoff_options = {}
+        handoff_options[:preserve_composer] = true if frozen_composer_command?(command)
+        result = run_interactive_pty_with_terminal_handoff(shell, command, env: env, cwd: cwd, **handoff_options) do |chunk|
+          remaining = MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES - output.bytesize
+          if chunk.bytesize > remaining
+            output << chunk.byteslice(0, remaining) if remaining.positive?
+            output_truncated = true
+          else
+            output << chunk
+          end
+        end
+        @prompt.refresh_composer_status if @prompt.respond_to?(:refresh_composer_status)
+        transcript_output = terminal_transcript_output(output, result, truncated: output_truncated)
+        if transcript_output && @prompt.respond_to?(:record_transient_terminal_output)
+          @prompt.record_transient_terminal_output(transcript_output)
+        end
+        result
       rescue Errno::ENOENT => e
         runtime_output("Error: #{e.message}")
+        nil
       end
 
-      def run_interactive_pty_with_terminal_handoff(shell, command, env:, cwd:)
+      def run_interactive_pty_with_terminal_handoff(shell, command, env:, cwd:, preserve_composer: false, &block)
         runner = InteractivePtyRunner.new
         if @prompt.respond_to?(:with_terminal_handoff)
-          @prompt.with_terminal_handoff do |input, output|
-            runner.run(shell, "-c", command, env: env, cwd: cwd, input: input, output: output)
+          if preserve_composer
+            @prompt.with_terminal_handoff(preserve_composer: true) do |input, output|
+              runner.run(shell, "-c", command, env: env, cwd: cwd, input: input, output: output, &block)
+            end
+          else
+            @prompt.with_terminal_handoff do |input, output|
+              runner.run(shell, "-c", command, env: env, cwd: cwd, input: input, output: output, &block)
+            end
           end
         else
-          runner.run(shell, "-c", command, env: env, cwd: cwd)
+          runner.run(shell, "-c", command, env: env, cwd: cwd, &block)
         end
       end
 
-      def interactive_pty_environment(configured_env)
+      def frozen_composer_command?(command)
+        FROZEN_COMPOSER_COMMANDS.match?(command.to_s.strip)
+      end
+
+      def terminal_transcript_output(output, result, truncated:)
+        return if truncated || result.input_forwarded
+
+        text = ANSI.normalize_transcript_encoding(output).gsub("\r\n", "\n")
+        return if text.empty? || text.include?("\r")
+
+        sanitized = ANSI.sanitize_transcript(text)
+        return unless sanitized == text
+        return if ANSI.strip_control_sequences(text).match?(UNSAFE_TRANSCRIPT_CONTROL_PATTERN)
+
+        sanitized
+      end
+
+      def interactive_pty_environment(configured_env, preserve_git_pager: false)
         ENV.to_h.merge(configured_env.to_h.transform_keys(&:to_s).transform_values(&:to_s)).tap do |env|
-          env.delete("GIT_PAGER") if env["GIT_PAGER"] == "cat"
+          env.delete("GIT_PAGER") if !preserve_git_pager && env["GIT_PAGER"] == "cat"
           env["TERM"] = "xterm-256color" if env["TERM"].to_s.empty? || env["TERM"] == "dumb"
         end
       end
@@ -248,14 +387,13 @@ module Kward
       end
 
       def run_ekwsh_interactive_pty_command(shell, result)
-        @prompt.say(result.output) unless result.output.to_s.empty?
-        pty_result = run_interactive_pty_with_terminal_handoff(
-          shell.command_shell,
+        run_user_interactive_pty_command(
           result.interactive_command,
+          shell: shell.command_shell,
           env: shell.child_env(interactive: true),
-          cwd: shell.cwd
+          cwd: shell.cwd,
+          intro: result.output
         )
-        @prompt.say("[interactive PTY session exited with status #{pty_result.exit_status}]\n") if @prompt.respond_to?(:say)
       end
 
       def run_ekwsh_command(shell, input)

data/lib/kward/cli/sessions.rb

@@ -21,7 +21,7 @@ module Kward
         path = session_store.remembered_last_session_path if session_store.respond_to?(:remembered_last_session_path)
         return nil if path.to_s.empty?
 
-        @active_session, conversation = session_store.load(path, workspace: configured_workspace(root: session_store.cwd), provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort)
+        @active_session, conversation = session_store.load(path, workspace: configured_workspace(root: session_store.cwd), provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort, project_skill_paths: project_skill_paths_for(session_store.cwd) || [])
         reset_session_diff(@active_session.path)
         track_session(@active_session)
         @resumed_last_session = true
@@ -99,6 +99,7 @@ module Kward
       def start_new_session(session_store)
         return say_sessions_unavailable unless session_store
 
+        prepare_interactive_project_skills if respond_to?(:prepare_interactive_project_skills, true)
         previous_session = @active_session
         @active_session = track_session(session_store.create)
         reset_session_diff
@@ -127,7 +128,7 @@ module Kward
 
       def load_session(session_store, path, message: nil)
         previous_session = @active_session
-        @active_session, conversation = session_store.load(path, workspace: configured_workspace(root: session_store.cwd), provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort)
+        @active_session, conversation = session_store.load(path, workspace: configured_workspace(root: session_store.cwd), provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort, project_skill_paths: project_skill_paths_for(session_store.cwd) || [])
         reset_session_diff(@active_session.path)
         track_session(@active_session)
         cleanup_replaced_session(previous_session)
@@ -396,7 +397,8 @@ module Kward
           workspace: configured_workspace(root: session_store.cwd),
           provider: current_model_provider,
           model: current_model_id,
-          reasoning_effort: current_reasoning_effort
+          reasoning_effort: current_reasoning_effort,
+          project_skill_paths: project_skill_paths_for(session_store.cwd) || []
         )
         reset_session_diff(@active_session.path)
         track_session(@active_session)
@@ -579,7 +581,7 @@ module Kward
       end
 
       def clone_session_file_from_path(session_store, path)
-        source_session, source_conversation = session_store.load(path, workspace: configured_workspace(root: session_store.cwd), provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort)
+        source_session, source_conversation = session_store.load(path, workspace: configured_workspace(root: session_store.cwd), provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort, project_skill_paths: project_skill_paths_for(session_store.cwd) || [])
         clone, = session_store.create_independent_from_conversation(source_conversation, parent_session: source_session)
         clone.path
       end

data/lib/kward/cli/settings.rb

@@ -956,7 +956,7 @@ module Kward
           refresh_reasoning_status
         else
           refresh_conversation_runtime(conversation, reasoning_effort: effort)
-          @prompt.redraw if @prompt.respond_to?(:redraw)
+          refresh_reasoning_status
         end
       end
 

data/lib/kward/cli/slash_commands.rb

@@ -32,6 +32,9 @@ module Kward
             run_busy_local_command_and_requeue { activate_skill_command(argument, agent) }
           end
           [true, nil]
+        when "skills"
+          run_busy_local_command_and_requeue { handle_project_skills_command(argument) }
+          [true, nil]
         when "redraw"
           run_busy_local_command_and_requeue { @prompt.redraw if @prompt.respond_to?(:redraw) }
           [true, nil]
@@ -47,6 +50,9 @@ module Kward
         when "shell"
           run_ekwsh(agent)
           [true, nil]
+        when "capture"
+          run_captured_shell_command(argument, agent)
+          [true, nil]
         when "scratchpad"
           open_scratchpad_command(argument)
           [true, nil]
@@ -345,7 +351,7 @@ module Kward
         percent = ((reserve_tokens.to_f / context_window.to_i) * 100).round(1)
         "Auto-compaction reserve: #{reserve_tokens} tokens (#{percent}% of #{context_window})"
       rescue StandardError => e
-        warn "Auto-compaction status unavailable: #{e.message}"
+        emit_warning "Auto-compaction status unavailable: #{e.message}"
         nil
       end
 

data/lib/kward/cli/tabs.rb

@@ -194,7 +194,7 @@ module Kward
 
       def restore_tab_session(session_store, path, workspace_root: session_store.cwd, strict: false)
         if File.file?(path)
-          session, conversation = session_store.load(path, workspace: configured_workspace(root: workspace_root, strict: strict), provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort)
+          session, conversation = session_store.load(path, workspace: configured_workspace(root: workspace_root, strict: strict), provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort, project_skill_paths: project_skill_paths_for(workspace_root) || [])
           return [track_session(session), conversation]
         end
 
@@ -215,9 +215,11 @@ module Kward
         git_committer = if strict
                           ->(message:, paths:) { git_commit_for_agent(workspace.root.to_s, message: message, paths: paths) }
                         end
+        project_skill_paths = project_skill_paths_for(conversation.workspace_root) || []
         tool_registry = ToolRegistry.new(
           workspace: workspace,
           prompt: prompt,
+          skills: ConfigFiles.skills(workspace_root: conversation.workspace_root, project_skill_paths: project_skill_paths),
           tool_approval: tab_tool_approval_callback(prompt),
           hook_manager: hook_manager,
           hook_context: hook_context,
@@ -230,6 +232,7 @@ module Kward
           client: @client,
           tool_registry: tool_registry,
           conversation: conversation,
+          warning_sink: ConfigFiles.warning_sink,
           hook_manager: hook_manager,
           hook_context: hook_context
         )

data/lib/kward/cli.rb

@@ -59,6 +59,8 @@ require_relative "cli/sysprompt"
 require_relative "cli/stats"
 require_relative "cli/openrouter_commands"
 require_relative "cli/runtime_helpers"
+require_relative "cli/project_skills"
+require_relative "cli/project_skills_commands"
 require_relative "cli/slash_commands"
 require_relative "cli/memory_commands"
 require_relative "cli/hook_commands"
@@ -94,6 +96,8 @@ module Kward
     include CLI::Stats
     include CLI::OpenRouterCommands
     include CLI::RuntimeHelpers
+    include CLI::ProjectSkills
+    include CLI::ProjectSkillsCommands
     include CLI::SlashCommands
     include CLI::MemoryCommands
     include CLI::HookCommands
@@ -232,6 +236,16 @@ module Kward
         return
       end
 
+      if @argv.first == "skills"
+        if help_option_arguments?(@argv[1..] || [])
+          print_command_help("skills")
+          return
+        end
+
+        handle_project_skills_cli_command(@argv[1..] || [])
+        return
+      end
+
       if @argv.first == "edit"
         if help_option_arguments?(@argv[1..] || [])
           print_command_help("edit")
@@ -333,6 +347,7 @@ module Kward
       @prompt.edit_file(path, base_dir: Dir.pwd, allow_new: true)
     ensure
       @prompt.close if @prompt.respond_to?(:close) && prompt_interface?
+      clear_interactive_warning_sink if respond_to?(:clear_interactive_warning_sink, true)
     end
 
     def run_prompt_or_interactive
@@ -429,7 +444,8 @@ module Kward
     end
 
     def interactive_loop(agent: nil)
-      setup_interactive_prompt
+      setup_interactive_prompt(defer_warnings: true)
+      prepare_interactive_project_skills
       session_store = interactive_session_store(agent)
       @resumed_last_session = false
       if session_store && @prompt.respond_to?(:update_tabs)
@@ -449,8 +465,10 @@ module Kward
 
       print_visual_banner unless @resumed_last_session || @restored_tabs
       render_resumed_last_session_transcript(agent.conversation) if @resumed_last_session
+      enable_interactive_warnings if respond_to?(:enable_interactive_warnings, true)
 
       @pending_inputs = []
+      install_bang_completion_provider(agent)
 
       loop do
         if @pending_inputs.empty? && active_tab&.shell
@@ -542,10 +560,12 @@ module Kward
       runtime_output("Goodbye.")
       active_tab&.agent&.conversation || agent&.conversation
     ensure
+      clear_bang_completion_provider
       begin
         stop_tabs if respond_to?(:stop_tabs, true)
         @prompt.close if prompt_interface?
       ensure
+        clear_interactive_warning_sink if respond_to?(:clear_interactive_warning_sink, true)
         cleanup_unused_sessions
         remember_active_session(session_store)
       end

data/lib/kward/compactor.rb

@@ -734,9 +734,10 @@ module Kward
     AUTO_COMPACTION_EXTRA_GUARD_FLOOR = 12_000
 
     # Creates an object for conversation compaction.
-    def initialize(conversation:, client:, tool_result_summarizer: nil, settings: nil, summarizer: nil)
+    def initialize(conversation:, client:, tool_result_summarizer: nil, settings: nil, summarizer: nil, warning_sink: nil)
       @conversation = conversation
       @client = client
+      @warning_sink = warning_sink
       @settings = settings || Compaction::Settings.from_config
       @prompt_builder = Compaction::PromptBuilder.new(
         serializer: Compaction::ConversationSerializer.new(tool_result_summarizer: tool_result_summarizer)
@@ -791,7 +792,7 @@ module Kward
     rescue Compaction::NothingToCompact, Compaction::AlreadyCompacted
       nil
     rescue StandardError => e
-      warn "Auto-compaction failed: #{e.message}"
+      emit_warning "Auto-compaction failed: #{e.message}"
       nil
     end
 
@@ -814,6 +815,10 @@ module Kward
 
     private
 
+    def emit_warning(message)
+      @warning_sink ? @warning_sink.call(message) : warn(message)
+    end
+
     def prepare
       @conversation.refresh_system_message_if_workspace_agents_changed!
       Compaction::Preparation.new(conversation: @conversation, settings: @settings).call

data/lib/kward/config_files.rb

@@ -66,6 +66,7 @@ module Kward
     end
 
     @skip_config = false
+    @warning_sink = nil
 
     module_function
 
@@ -73,6 +74,14 @@ module Kward
       @skip_config = value
     end
 
+    def warning_sink=(sink)
+      @warning_sink = sink
+    end
+
+    def warning_sink
+      @warning_sink
+    end
+
     def skip_config?
       @skip_config == true
     end
@@ -791,13 +800,13 @@ module Kward
 
       size = File.size(path)
       if size > MAX_PROMPT_FILE_BYTES
-        warn "Warning: skipping #{label} #{path}: file too large (#{size} bytes; limit is #{MAX_PROMPT_FILE_BYTES} bytes)"
+        emit_warning "Warning: skipping #{label} #{path}: file too large (#{size} bytes; limit is #{MAX_PROMPT_FILE_BYTES} bytes)"
         return nil
       end
 
       File.read(path)
     rescue StandardError => e
-      warn "Warning: skipping #{label} #{path}: #{e.message}"
+      emit_warning "Warning: skipping #{label} #{path}: #{e.message}"
       nil
     end
 
@@ -908,8 +917,12 @@ module Kward
     # Lists configured skills discovered under the config directory.
     #
     # @return [Array<Skill>] skill metadata available to the model
-    def skills(workspace_root: Dir.pwd)
-      skills_registry(workspace_root: workspace_root).skills
+    def skills(workspace_root: Dir.pwd, warning_sink: nil, project_skill_paths: nil)
+      skills_registry(workspace_root: workspace_root, warning_sink: warning_sink, project_skill_paths: project_skill_paths).skills
+    end
+
+    def project_skill_candidates(workspace_root: Dir.pwd, warning_sink: nil)
+      skills_registry(workspace_root: workspace_root, warning_sink: warning_sink).project_skill_candidates
     end
 
     # @return [String] trusted user plugin directory
@@ -923,7 +936,7 @@ module Kward
     # workspace or custom `KWARD_CONFIG_PATH` directory.
     #
     # @return [Array<String>] sorted plugin file paths
-    def plugin_paths
+    def plugin_paths(warning_sink: nil)
       plugins_root = plugin_dir
       return [] unless Dir.exist?(plugins_root)
 
@@ -931,7 +944,7 @@ module Kward
       paths.concat(Dir.glob(File.join(plugins_root, "*", "plugin.rb")))
       paths.sort
     rescue StandardError => e
-      warn "Warning: skipping Kward plugins in #{plugins_root}: #{e.message}"
+      emit_warning("Warning: skipping Kward plugins in #{plugins_root}: #{e.message}", warning_sink: warning_sink)
       []
     end
 
@@ -952,7 +965,7 @@ module Kward
       skills_registry(workspace_root: workspace_root).read_skill_file(name, relative_path)
     end
 
-    def skills_registry(workspace_root: Dir.pwd)
+    def skills_registry(workspace_root: Dir.pwd, warning_sink: nil, project_skill_paths: nil)
       Skills::Registry.new(
         config_dir: config_dir,
         workspace_root: workspace_root,
@@ -960,7 +973,9 @@ module Kward
         skill_class: Skill,
         max_file_bytes: MAX_SKILL_FILE_BYTES,
         markdown_parser: ->(path) { Frontmatter.markdown_parts(path, lenient: true) },
-        inside_directory: method(:inside_directory?)
+        inside_directory: method(:inside_directory?),
+        warning_sink: warning_sink || @warning_sink,
+        project_skill_paths: project_skill_paths
       )
     end
 
@@ -968,10 +983,16 @@ module Kward
       Prompts::Templates.new(
         config_dir: config_dir,
         template_class: PromptTemplate,
-        markdown_parser: ->(path) { Frontmatter.markdown_parts(path) }
+        markdown_parser: ->(path) { Frontmatter.markdown_parts(path) },
+        warning_sink: @warning_sink
       )
     end
 
+    def emit_warning(message, warning_sink: nil)
+      sink = warning_sink || @warning_sink
+      sink ? sink.call(message) : warn(message)
+    end
+
     def inside_directory?(path, base)
       PathGuard.inside?(path, base)
     end

data/lib/kward/conversation.rb

@@ -63,13 +63,16 @@ module Kward
     attr_reader :tool_output_artifacts
     # @return [ContextBudgetMeter] runtime context savings for this conversation
     attr_reader :context_budget_meter
+    # @return [Array<String>, nil] explicitly permitted project skill paths
+    attr_reader :project_skill_paths
 
-    def initialize(system_message: DEFAULT_SYSTEM_MESSAGE, messages: [], read_paths: [], on_append: nil, on_compact: nil, on_tool_execution: nil, on_runtime_update: nil, workspace_root: Dir.pwd, compaction_system_message: DEFAULT_SYSTEM_MESSAGE, provider: nil, model: nil, reasoning_effort: nil, memory_context: nil, session_memories: [], last_memory_retrieval: nil, plugin_registry: nil, execution_profile_context: nil)
+    def initialize(system_message: DEFAULT_SYSTEM_MESSAGE, messages: [], read_paths: [], on_append: nil, on_compact: nil, on_tool_execution: nil, on_runtime_update: nil, workspace_root: Dir.pwd, compaction_system_message: DEFAULT_SYSTEM_MESSAGE, provider: nil, model: nil, reasoning_effort: nil, memory_context: nil, session_memories: [], last_memory_retrieval: nil, plugin_registry: nil, execution_profile_context: nil, project_skill_paths: nil)
       @workspace_root = ConfigFiles.canonical_workspace_root(workspace_root)
       @provider = provider
       @model = model
       @reasoning_effort = reasoning_effort
       @plugin_registry = plugin_registry
+      @project_skill_paths = project_skill_paths
       @execution_profile_context = execution_profile_context.to_s.empty? ? nil : execution_profile_context.to_s.freeze
       @messages = []
       restored_system_message, transcript_messages = split_system_message(messages)
@@ -78,13 +81,13 @@ module Kward
           system_message = restored_system_message
         else
           @last_plugin_prompt_context = plugin_prompt_context
-          system_message = Prompts.system_message(workspace_root: @workspace_root, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, memory_context: memory_context, plugin_context: @last_plugin_prompt_context, execution_profile_context: @execution_profile_context)
+          system_message = Prompts.system_message(workspace_root: @workspace_root, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, memory_context: memory_context, plugin_context: @last_plugin_prompt_context, execution_profile_context: @execution_profile_context, project_skill_paths: @project_skill_paths)
         end
       end
       @system_message = system_message
       @system_message_enabled = !@system_message.nil?
       if compaction_system_message.equal?(DEFAULT_SYSTEM_MESSAGE)
-        compaction_system_message = @system_message_enabled ? Prompts.system_message(workspace_root: @workspace_root, include_workspace_personality: false, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, execution_profile_context: @execution_profile_context) : nil
+        compaction_system_message = @system_message_enabled ? Prompts.system_message(workspace_root: @workspace_root, include_workspace_personality: false, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, execution_profile_context: @execution_profile_context, project_skill_paths: @project_skill_paths) : nil
       end
       @compaction_system_message = compaction_system_message
       @workspace_agents_mtime = workspace_agents_mtime
@@ -188,10 +191,10 @@ module Kward
       return nil unless @system_message_enabled
 
       @last_plugin_prompt_context = plugin_prompt_context
-      replacement = Prompts.system_message(workspace_root: @workspace_root, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, memory_context: @memory_context, plugin_context: @last_plugin_prompt_context, execution_profile_context: @execution_profile_context)
+      replacement = Prompts.system_message(workspace_root: @workspace_root, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, memory_context: @memory_context, plugin_context: @last_plugin_prompt_context, execution_profile_context: @execution_profile_context, project_skill_paths: @project_skill_paths)
       @system_message = replacement
       @on_system_message_change&.call(replacement)
-      @compaction_system_message = Prompts.system_message(workspace_root: @workspace_root, include_workspace_personality: false, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, execution_profile_context: @execution_profile_context)
+      @compaction_system_message = Prompts.system_message(workspace_root: @workspace_root, include_workspace_personality: false, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, execution_profile_context: @execution_profile_context, project_skill_paths: @project_skill_paths)
       @workspace_agents_mtime = workspace_agents_mtime
       @system_prompt_sources_fingerprint = ConfigFiles.system_prompt_sources_fingerprint
       replacement