kward 0.80.1 → 0.81.0

data/lib/kward/cli/interactive_turn.rb

@@ -8,7 +8,6 @@ module Kward
 
       def run_interactive_turn(agent, input, display_input: nil)
         prepare_memory_context(agent.conversation, input) if agent.respond_to?(:conversation)
-        print_user_transcript(input, display_input: display_input) if prompt_interface?
         return run_blocking_interactive_turn(agent, input, display_input: display_input) unless prompt_interface?
 
         queued_inputs = []
@@ -27,6 +26,7 @@ module Kward
         answer = nil
         error = nil
         @prompt.begin_busy_input("You>") if @prompt.respond_to?(:begin_busy_input)
+        print_user_transcript(input, display_input: display_input)
 
         worker = Thread.new do
           options = agent_display_options(display_input)

data/lib/kward/cli/plugins.rb

@@ -122,7 +122,7 @@ module Kward
             argument_hint: template.argument_hint
           }
         end
-        skill_entries = ConfigFiles.skills.map do |skill|
+        skill_entries = ConfigFiles.skills(workspace_root: current_workspace_root, project_skill_paths: @interactive_project_skill_paths || []).map do |skill|
           {
             name: "skill:#{skill.name}",
             description: skill.description,

data/lib/kward/cli/project_skills.rb

@@ -0,0 +1,99 @@
+require "pathname"
+require_relative "../skills/trust_coordinator"
+require_relative "../skills/trust_store"
+
+# Namespace for CLI orchestration helpers.
+module Kward
+  class CLI
+    # Coordinates interactive trust decisions for project-provided Agent Skills.
+    module ProjectSkills
+      private
+
+      def prepare_interactive_project_skills
+        return unless prompt_interface?
+
+        workspace_root = current_workspace_root
+        candidates = ConfigFiles.project_skill_candidates(workspace_root: workspace_root)
+        trust_store = Skills::TrustStore.new(config_dir: ConfigFiles.config_dir)
+        coordinator = Skills::TrustCoordinator.new(workspace_root: workspace_root, trust_store: trust_store)
+
+        if ConfigFiles.project_skills_trusted?
+          @interactive_project_skill_paths = candidates.map(&:path)
+        else
+          pending = coordinator.pending(candidates)
+          unless pending.empty?
+            decision = prompt_for_project_skill_trust(pending)
+            coordinator.record!(pending, decision)
+          end
+
+          @interactive_project_skill_paths = coordinator.allowed_paths(candidates)
+        end
+      end
+
+      def prompt_for_project_skill_trust(candidates)
+        paths = candidates.map { |candidate| "  #{relative_workspace_path(candidate.path)}" }
+        message = (["Project skills found in #{current_workspace_root}:", *paths, "", "These files contain instructions that may influence the model."]).join("\n")
+        loop do
+          choice = @prompt.select(message, ["Allow", "Deny", "Review"], title: "Trust project skills")
+          case choice.to_s.downcase
+          when "review"
+            review_project_skills(candidates)
+          when "allow"
+            return "allow"
+          else
+            return "deny"
+          end
+        end
+      end
+
+      def review_project_skills(candidates)
+        candidates.each do |candidate|
+          content = read_project_skill_for_review(candidate.path)
+          resources = project_skill_resources(candidate.path)
+          details = [
+            "Project skill: #{relative_workspace_path(candidate.path)}",
+            resources.empty? ? nil : "Referenced resources:\n#{resources.map { |path| "  #{path}" }.join("\n")}",
+            "",
+            content
+          ].compact.join("\n")
+          @prompt.say("\n#{ANSI.strip(details)}\n")
+        end
+      end
+
+      def read_project_skill_for_review(path)
+        return "Unable to review: file is too large." if File.size(path) > ConfigFiles::MAX_SKILL_FILE_BYTES
+
+        ANSI.strip(File.read(path, ConfigFiles::MAX_SKILL_FILE_BYTES + 1))
+      rescue StandardError => e
+        "Unable to review: #{e.message}"
+      end
+
+      def project_skill_resources(path)
+        folder = File.dirname(path)
+        roots = %w[scripts references assets].map { |name| File.join(folder, name) }.select { |root| Dir.exist?(root) }
+        roots.flat_map { |root| Dir.glob(File.join(root, "**", "*")).select { |entry| File.file?(entry) } }.sort.first(200).map do |resource|
+          Pathname.new(resource).relative_path_from(Pathname.new(folder)).to_s
+        end
+      rescue StandardError
+        []
+      end
+
+      def project_skill_paths_for(workspace_root)
+        return unless @interactive_project_skill_paths
+        return unless canonical_path(workspace_root) == canonical_path(current_workspace_root)
+
+        @interactive_project_skill_paths
+      end
+
+      def canonical_path(path)
+        File.realpath(path)
+      rescue SystemCallError
+        File.expand_path(path)
+      end
+
+      def relative_workspace_path(path)
+        Pathname.new(File.expand_path(path)).relative_path_from(Pathname.new(File.expand_path(current_workspace_root))).to_s
+      end
+    end
+  end
+end

data/lib/kward/cli/project_skills_commands.rb

@@ -0,0 +1,87 @@
+# Namespace for CLI orchestration helpers.
+module Kward
+  class CLI
+    # Handles explicit project skill trust management commands.
+    module ProjectSkillsCommands
+      def handle_project_skills_cli_command(arguments)
+        argument = Array(arguments).join(" ").strip.downcase
+        _workspace_root, candidates, coordinator = project_skill_trust_coordinator
+        if candidates.empty? && argument != "untrust"
+          @prompt.say("No project skills found in the current workspace.")
+          return
+        end
+
+        case argument
+        when "", "status"
+          lines = candidates.empty? ? ["No project skills found in the current workspace."] : candidates.map { |candidate| "#{relative_workspace_path(candidate.path)}: #{coordinator.decision(candidate) || "needs review"}" }
+          @prompt.say(lines.join("\n"))
+        when "trust"
+          coordinator.record!(candidates, "allow")
+          @prompt.say("Project skills trusted for the current skill snapshots.")
+        when "untrust"
+          coordinator.remove_workspace!
+          @prompt.say("Project skill trust removed for this workspace.")
+        when "review"
+          review_project_skills(candidates)
+        else
+          raise ArgumentError, "Usage: kward skills [status|trust|untrust|review]"
+        end
+      end
+
+      def handle_project_skills_command(argument)
+        case argument.to_s.strip.downcase
+        when "", "status"
+          show_project_skills_status
+        when "trust"
+          trust_current_project_skills
+        when "untrust"
+          untrust_current_project_skills
+        else
+          runtime_output("Usage: /skills [status|trust|untrust]")
+        end
+      end
+
+      private
+
+      def project_skill_trust_coordinator
+        workspace_root = current_workspace_root
+        candidates = ConfigFiles.project_skill_candidates(workspace_root: workspace_root)
+        store = Skills::TrustStore.new(config_dir: ConfigFiles.config_dir)
+        [workspace_root, candidates, Skills::TrustCoordinator.new(workspace_root: workspace_root, trust_store: store)]
+      end
+
+      def show_project_skills_status
+        _workspace_root, candidates, coordinator = project_skill_trust_coordinator
+        if candidates.empty?
+          runtime_output("No project skills found in the current workspace.")
+          return
+        end
+
+        lines = candidates.map do |candidate|
+          status = coordinator.decision(candidate) || "needs review"
+          "#{relative_workspace_path(candidate.path)}: #{status}"
+        end
+        runtime_output(lines.join("\n"))
+      end
+
+      def trust_current_project_skills
+        _workspace_root, candidates, coordinator = project_skill_trust_coordinator
+        if candidates.empty?
+          runtime_output("No project skills found in the current workspace.")
+          return
+        end
+
+        coordinator.record!(candidates, "allow")
+        @interactive_project_skill_paths = coordinator.allowed_paths(candidates)
+        runtime_output("Project skills trusted for the current skill snapshots. Use /new to rebuild the agent.")
+      end
+
+      def untrust_current_project_skills
+        _workspace_root, _candidates, coordinator = project_skill_trust_coordinator
+        coordinator.remove_workspace!
+        @interactive_project_skill_paths = []
+        runtime_output("Project skill trust removed for this workspace. Use /new to rebuild the agent.")
+      end
+    end
+  end
+end

data/lib/kward/cli/prompt_interface.rb

@@ -8,7 +8,7 @@ module Kward
     module PromptInterfaceSupport
       private
 
-      def setup_interactive_prompt
+      def setup_interactive_prompt(defer_warnings: false)
         return unless @stdin.tty?
         return unless @prompt.is_a?(TTY::Prompt)
 
@@ -16,6 +16,7 @@ module Kward
         return unless prompt_interface
 
         @interactive_warning_sink_active = true
+        @interactive_warning_output_ready = !defer_warnings
         ConfigFiles.warning_sink = interactive_warning_sink
         @prompt = prompt_interface.new(
           slash_commands: slash_command_entries,
@@ -43,13 +44,19 @@ module Kward
           editor_line_numbers: ConfigFiles.editor_line_numbers,
           editor_line_numbers_source: -> { ConfigFiles.editor_line_numbers },
           diff_view: ConfigFiles.diff_view,
-          diff_view_source: -> { ConfigFiles.diff_view }
+          diff_view_source: -> { ConfigFiles.diff_view },
+          redraw_handler: method(:redraw_interactive_prompt)
         )
         if @prompt.method(:start).parameters.any? { |kind, name| [:key, :keyreq].include?(kind) && name == :render }
           @prompt.start(render: false)
         else
           @prompt.start
         end
+        flush_interactive_warnings if @interactive_warning_output_ready
+      end
+
+      def enable_interactive_warnings
+        @interactive_warning_output_ready = true
         flush_interactive_warnings
       end
 
@@ -60,7 +67,7 @@ module Kward
             next
           end
 
-          if prompt_interface?
+          if @interactive_warning_output_ready && prompt_interface?
             runtime_output(message)
           else
             (@pending_interactive_warnings ||= []) << message
@@ -100,6 +107,7 @@ module Kward
       def clear_interactive_warning_sink
         ConfigFiles.warning_sink = nil
         @interactive_warning_sink_active = false
+        @interactive_warning_output_ready = false
         @pending_interactive_warnings = nil
         @interactive_warning_sink = nil
       end
@@ -158,10 +166,16 @@ module Kward
       end
 
       def startup_plugins_value
-        filenames = plugin_registry.paths.map { |path| File.basename(path) }
+        filenames = plugin_registry.paths.map { |path| startup_plugin_name(path) }
         filenames.empty? ? "none" : filenames.join(", ")
       end
 
+      def startup_plugin_name(path)
+        plugin_root = ConfigFiles.plugin_dir
+        prefix = "#{plugin_root}#{File::SEPARATOR}"
+        path.start_with?(prefix) ? path.delete_prefix(prefix) : File.basename(path)
+      end
+
       def startup_status_line(refresh_update_check: false)
         color = startup_update_notice(refresh: refresh_update_check) ? :yellow : :green
         "#{ANSI.colorize("●", color, enabled: @color_enabled)} Kward v#{Kward::VERSION} is online."

data/lib/kward/cli/rendering.rb

@@ -10,6 +10,24 @@ module Kward
         render_transcript_messages(conversation.messages)
       end
 
+      def redraw_interactive_prompt
+        tab = active_tab if respond_to?(:active_tab, true)
+        if tab && (tab.running? || tab.shell)
+          @prompt.redraw if @prompt.respond_to?(:redraw)
+          return
+        end
+
+        conversation = tab&.agent&.conversation || @footer_conversation
+        unless conversation && @prompt.respond_to?(:restore_transcript)
+          @prompt.redraw if @prompt.respond_to?(:redraw)
+          return
+        end
+
+        restore_prompt_transcript do
+          tab ? render_transcript_messages(tab.driver.messages) : render_conversation_transcript(conversation)
+        end
+      end
+
       # Renders a transcript supplied by either a Kward conversation or a
       # plugin-owned tab driver.
       def render_transcript_messages(messages)
@@ -199,7 +217,7 @@ module Kward
       # Writes the user transcript output for the terminal CLI flow.
       def print_user_transcript(input, display_input: nil, attachment_references: nil, image_parts: nil)
         visible_input = display_input.nil? ? input : display_input
-        @prompt.say("\n#{colored("You>", :blue, :bold)} #{visible_input}\n")
+        write_prompt_transcript("\n#{colored("You>", :blue, :bold)} #{visible_input}\n")
         print_attachment_badges(input, references: attachment_references)
         print_pasted_images(input, image_parts: image_parts)
       end
@@ -209,7 +227,15 @@ module Kward
         badges = references ? Array(references).map { |reference| attachment_badge_text(reference) } : composer_attachment_badges(input)
         return if badges.empty?
 
-        @prompt.say("#{badges.join("\n")}\n")
+        write_prompt_transcript("#{badges.join("\n")}\n")
+      end
+
+      def write_prompt_transcript(message)
+        if @prompt.respond_to?(:write_transcript)
+          @prompt.write_transcript(message)
+        else
+          @prompt.say(message)
+        end
       end
 
       def composer_attachment_badges(input, attachments = [])

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
@@ -86,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.")
@@ -140,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
@@ -249,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]

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,