kward 0.80.0 → 0.81.0

data/lib/kward/ansi.rb

@@ -67,7 +67,7 @@ module Kward
 
     # Drops unsafe terminal controls from transcript text while preserving SGR color.
     def sanitize_transcript(text)
-      scan_escape_tokens(text).each_with_object(+"") do |token, sanitized|
+      scan_escape_tokens(normalize_transcript_encoding(text)).each_with_object(+"") do |token, sanitized|
         if token[:escape]
           sanitized << token[:text] if token[:text].match?(SGR_PATTERN)
         else
@@ -76,6 +76,14 @@ module Kward
       end
     end
 
+    def normalize_transcript_encoding(text)
+      string = text.to_s.dup
+      return string unless string.encoding == Encoding::ASCII_8BIT
+
+      string.force_encoding(Encoding::UTF_8)
+      string.valid_encoding? ? string : string.scrub
+    end
+
     def wrap_visible(text, width)
       line_width = [width.to_i, 1].max
       rows = []

data/lib/kward/cli/commands.rb

@@ -54,6 +54,7 @@ module Kward
             #{command.call("kward init")}                         Install starter prompts and PRINCIPLES.md
             #{command.call("kward doctor")}                       Check local Kward setup
             #{command.call("kward hooks doctor")}                 Inspect lifecycle hook setup
+            #{command.call("kward skills status")}                 Inspect project skill trust
             #{command.call("kward edit")} #{option.call("<filename>")}              Open a file in the integrated editor
             #{command.call("kward sysprompt")}                    Inspect the effective system prompt
             #{command.call("kward openrouter refresh")}           Refresh cached OpenRouter models
@@ -69,6 +70,7 @@ module Kward
             #{command.call("init")}                               Install starter prompts and PRINCIPLES.md
             #{command.call("doctor")}                             Check local Kward setup
             #{command.call("hooks list|events|logs|doctor|trust|untrust")} Inspect lifecycle hooks
+            #{command.call("skills status|trust|untrust|review")}  Manage project skill trust
             #{command.call("edit")} #{option.call("<filename>")}                  Open a file in the integrated editor
             #{command.call("sysprompt")} [--raw]                  Inspect the effective system prompt
             #{command.call("stats tokens")} [range] [options]      Export local token telemetry as CSV
@@ -136,6 +138,11 @@ module Kward
             description: "Inspect lifecycle hooks, recent audit records, diagnostics, and workspace hook trust.",
             examples: ["kward hooks list", "kward hooks doctor", "kward hooks logs 50", "kward hooks trust"]
           },
+          "skills" => {
+            usage: "kward skills [status|trust|untrust|review]",
+            description: "Inspect or manage project skill trust for the current workspace.",
+            examples: ["kward skills status", "kward skills review", "kward skills trust"]
+          },
           "edit" => {
             usage: "kward edit <filename>",
             description: "Open a file in the integrated editor.",

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/memory_commands.rb

@@ -104,7 +104,7 @@ module Kward
       def prepare_memory_context(conversation, input)
         Memory::TurnContext.apply(conversation: conversation, input: input)
       rescue StandardError => e
-        warn "Memory retrieval failed: #{e.message}"
+        emit_warning "Memory retrieval failed: #{e.message}"
         nil
       end
 
@@ -120,7 +120,7 @@ module Kward
 
         summarize_memory(conversation, manager: manager)
       rescue StandardError => e
-        warn "Memory auto-summary failed: #{e.message}"
+        emit_warning "Memory auto-summary failed: #{e.message}"
         nil
       end
 

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,13 +8,16 @@ 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)
 
         prompt_interface = load_prompt_interface
         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,
           overlay_settings: ConfigFiles.overlay_settings,
@@ -41,13 +44,41 @@ 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
+
+      def interactive_warning_sink
+        @interactive_warning_sink ||= lambda do |message|
+          unless @interactive_warning_sink_active
+            warn message
+            next
+          end
+
+          if @interactive_warning_output_ready && prompt_interface?
+            runtime_output(message)
+          else
+            (@pending_interactive_warnings ||= []) << message
+          end
+        end
+      end
+
+      def flush_interactive_warnings
+        warnings = @pending_interactive_warnings
+        @pending_interactive_warnings = []
+        Array(warnings).each { |message| runtime_output(message) }
       end
 
       def load_prompt_interface
@@ -68,6 +99,19 @@ module Kward
         @prompt.respond_to?(:start_stream_block) && @prompt.respond_to?(:write_delta)
       end
 
+      def emit_warning(message)
+        sink = ConfigFiles.warning_sink
+        sink ? sink.call(message) : warn(message)
+      end
+
+      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
+
       def update_prompt_workspace_root(root)
         return unless @prompt.respond_to?(:update_workspace_root)
 
@@ -122,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."
@@ -179,7 +229,7 @@ module Kward
           context = plugin_context(current_footer_conversation, "")
           renderer.call(context).to_s
         rescue StandardError => e
-          warn "Warning: Kward plugin footer error: #{e.message}"
+          emit_warning "Warning: Kward plugin footer error: #{e.message}"
           ""
         end
       end

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 = [])