kward 0.80.1 → 0.82.0

data/lib/kward/adaptive_pty_output_sink.rb

@@ -0,0 +1,183 @@
+require_relative "terminal_sequences"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Streams a conservative subset of PTY output into Kward's inline terminal
+  # region and permanently switches to exclusive passthrough before forwarding
+  # screen-oriented or unknown terminal controls.
+  class AdaptivePtyOutputSink
+    MAX_SEQUENCE_BYTES = 4096
+    SAFE_CONTROLS = [0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d].freeze
+    TERMINAL_STRING_INTRODUCERS = [0x5d, 0x50, 0x5e, 0x5f, 0x58].freeze
+
+    attr_reader :captured_output
+
+    def initialize(output:, on_exclusive:, max_capture_bytes: nil)
+      @output = output
+      @on_exclusive = on_exclusive
+      @max_capture_bytes = max_capture_bytes
+      @captured_output = max_capture_bytes ? +"".b : nil
+      @capture_open = true
+      @truncated = false
+      @mode = :inline
+      @sequence = +"".b
+      @synchronized_output = false
+    end
+
+    def write(chunk)
+      value = chunk.to_s.b
+      capture(value)
+      return @output.write(value) if exclusive?
+
+      write_inline(value)
+    end
+
+    def flush
+      @output.flush if @output.respond_to?(:flush)
+    end
+
+    def finish
+      switch_to_exclusive(@sequence) unless @sequence.empty? || exclusive?
+      end_synchronized_output if inline?
+      flush
+    end
+
+    def input_forwarded
+      @capture_open = false
+    end
+
+    def inline?
+      @mode == :inline
+    end
+
+    def transcript_safe?
+      inline? && @sequence.empty?
+    end
+
+    def pre_input_capture_only?
+      true
+    end
+
+    def truncated?
+      @truncated
+    end
+
+    private
+
+    def exclusive?
+      @mode == :exclusive
+    end
+
+    def write_inline(value)
+      safe_output = +"".b
+      index = 0
+      while index < value.bytesize
+        byte = value.getbyte(index)
+        if @sequence.empty?
+          if byte == 0x1b
+            @sequence << byte
+          elsif byte >= 0x20 || SAFE_CONTROLS.include?(byte)
+            safe_output << byte
+          else
+            flush_safe_output(safe_output)
+            switch_to_exclusive(value.byteslice(index..))
+            return
+          end
+        else
+          @sequence << byte
+          status = sequence_status
+          if status == :safe
+            track_safe_sequence(@sequence)
+            safe_output << @sequence
+            @sequence.clear
+          elsif status == :exclusive
+            flush_safe_output(safe_output)
+            remainder = value.byteslice((index + 1)..).to_s.b
+            switch_to_exclusive(@sequence + remainder)
+            @sequence.clear
+            return
+          end
+        end
+        index += 1
+      end
+      flush_safe_output(safe_output)
+    end
+
+    def sequence_status
+      return :exclusive if @sequence.bytesize > MAX_SEQUENCE_BYTES
+      return :pending if @sequence.bytesize == 1
+
+      second = @sequence.getbyte(1)
+      return csi_status if second == "[".ord
+      return :exclusive if TERMINAL_STRING_INTRODUCERS.include?(second)
+      return escape_intermediate_status if second.between?(0x20, 0x2f)
+
+      :exclusive
+    end
+
+    def csi_status
+      return :pending if @sequence.bytesize == 2
+
+      byte = @sequence.getbyte(-1)
+      return safe_csi? ? :safe : :exclusive if byte.between?(0x40, 0x7e)
+      return :pending if byte.between?(0x20, 0x3f)
+
+      :exclusive
+    end
+
+    def escape_intermediate_status
+      byte = @sequence.getbyte(-1)
+      return :pending if byte.between?(0x20, 0x2f)
+
+      :exclusive
+    end
+
+    def safe_csi?
+      value = @sequence
+      value.match?(/\A\e\[[0-9:;]*m\z/) ||
+        value.match?(/\A\e\[[0-2]?K\z/) ||
+        value.match?(/\A\e\[[0-9;]*[CDG`]\z/) ||
+        value.match?(/\A\e\[\?25[hl]\z/) ||
+        value.match?(/\A\e\[\?(?:2004|2026)[hl]\z/) ||
+        value.match?(/\A\e\[[0-9;]* q\z/)
+    end
+
+    def track_safe_sequence(sequence)
+      @synchronized_output = true if sequence == TerminalSequences::SYNCHRONIZED_OUTPUT_ENABLE
+      @synchronized_output = false if sequence == TerminalSequences::SYNCHRONIZED_OUTPUT_DISABLE
+    end
+
+    def end_synchronized_output
+      return unless @synchronized_output
+
+      @output.write(TerminalSequences::SYNCHRONIZED_OUTPUT_DISABLE)
+      @synchronized_output = false
+    end
+
+    def flush_safe_output(value)
+      return if value.empty?
+
+      @output.write(value)
+      value.clear
+    end
+
+    def switch_to_exclusive(value)
+      end_synchronized_output
+      @on_exclusive.call
+      @mode = :exclusive
+      @output.write(value) unless value.empty?
+    end
+
+    def capture(value)
+      return unless @captured_output && @capture_open
+
+      remaining = @max_capture_bytes - @captured_output.bytesize
+      if value.bytesize > remaining
+        @captured_output << value.byteslice(0, remaining) if remaining.positive?
+        @truncated = true
+      else
+        @captured_output << value
+      end
+    end
+  end
+end

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

@@ -30,12 +30,16 @@ module Kward
           status = result.is_a?(Hash) && result.key?(:status_lines) ? result[:status_lines] : result
           result
         end
-        return if message.nil?
+        if message.nil?
+          refresh_composer_status
+          return
+        end
 
         result = run_busy_local_command_and_requeue(activity: "committing") do
           git_commit(git_root, message)
         end
         print_git_commit_result(result)
+        refresh_composer_status
       ensure
         @git_hook_conversation = previous_git_hook_conversation
       end

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,30 @@ module Kward
         render_transcript_messages(conversation.messages)
       end
 
+      def redraw_interactive_prompt
+        tab = active_tab if respond_to?(:active_tab, true)
+        clear_active_tab_transient_shell_output if tab && respond_to?(:clear_active_tab_transient_shell_output, true)
+        if tab&.shell
+          render_tab(tab, restore_composer: false)
+          return
+        end
+        if tab&.running?
+          @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)
+          render_tab_transient_shell_entries(tab) if tab && respond_to?(:render_tab_transient_shell_entries, true)
+        end
+      end
+
       # Renders a transcript supplied by either a Kward conversation or a
       # plugin-owned tab driver.
       def render_transcript_messages(messages)
@@ -199,7 +223,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 +233,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 = [])
@@ -257,8 +289,14 @@ module Kward
       # Writes the pasted images output for the terminal CLI flow.
       def print_pasted_images(input, image_parts: nil)
         parts = image_parts || Kward::ImageAttachments.image_parts_from_text(input)
+        protocol = @prompt.inline_image_protocol if @prompt.respond_to?(:inline_image_protocol)
         parts.each do |part|
-          sequence = Kward::ImageAttachments.terminal_image_sequence(part)
+          next if @prompt.respond_to?(:inline_image_protocol) && protocol.nil?
+
+          part = Kward::ImageAttachments.terminal_image_part(part, protocol) if protocol
+          next if protocol && part.nil?
+
+          sequence = Kward::ImageAttachments.terminal_image_sequence(part, protocol: protocol)
           next unless sequence
 
           if @prompt.respond_to?(:say_visual)