kward 0.80.1 → 0.82.0

data/lib/kward/pty_output_sink.rb

@@ -0,0 +1,45 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Forwards PTY output immediately and optionally keeps a bounded byte copy.
+  #
+  # The runner only depends on the sink's `write` method and optional `flush`
+  # method. Capture is deliberately byte-oriented so PTY chunk boundaries have
+  # no effect on the retained output.
+  class PassthroughPtyOutputSink
+    attr_reader :captured_output
+
+    def initialize(output:, max_capture_bytes: nil)
+      @output = output
+      @max_capture_bytes = max_capture_bytes
+      @captured_output = max_capture_bytes ? +"".b : nil
+      @truncated = false
+    end
+
+    def write(chunk)
+      @output.write(chunk)
+      capture(chunk)
+    end
+
+    def flush
+      @output.flush if @output.respond_to?(:flush)
+    end
+
+    def truncated?
+      @truncated
+    end
+
+    private
+
+    def capture(chunk)
+      return unless @captured_output
+
+      remaining = @max_capture_bytes - @captured_output.bytesize
+      if chunk.bytesize > remaining
+        @captured_output << chunk.byteslice(0, remaining) if remaining.positive?
+        @truncated = true
+      else
+        @captured_output << chunk
+      end
+    end
+  end
+end

data/lib/kward/pty_transcript_normalizer.rb

@@ -0,0 +1,93 @@
+require_relative "ansi"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Reduces safe, line-oriented PTY redraws to transcript-friendly text.
+  class PtyTranscriptNormalizer
+    HORIZONTAL_REDRAW_PATTERN = /\r|\e\[[0-9;]*[CDGK`]/.freeze
+
+    def self.normalize(text)
+      text.split("\n", -1).map do |line|
+        if line.match?(HORIZONTAL_REDRAW_PATTERN)
+          Line.new(line).render
+        else
+          ANSI.sanitize_transcript(line)
+        end
+      end.join("\n")
+    end
+
+    # Applies the horizontal cursor controls accepted by AdaptivePtyOutputSink
+    # without modeling a complete terminal screen.
+    class Line
+      def initialize(text)
+        @text = text
+        @cells = []
+        @cursor = 0
+      end
+
+      def render
+        ANSI.scan_escape_tokens(@text).each do |token|
+          token[:escape] ? apply_escape(token[:text]) : write_text(token[:text])
+        end
+        @cells.join.rstrip
+      end
+
+      private
+
+      def apply_escape(sequence)
+        final = sequence[-1]
+        return set_column(sequence) if final == "G" || final == "`"
+        return move_cursor(sequence, 1) if final == "C"
+        return move_cursor(sequence, -1) if final == "D"
+        return erase_line(sequence) if final == "K"
+      end
+
+      def set_column(sequence)
+        @cursor = [parameter(sequence, default: 1), 1].max - 1
+      end
+
+      def move_cursor(sequence, direction)
+        distance = [parameter(sequence, default: 1), 1].max
+        @cursor = [@cursor + (distance * direction), 0].max
+      end
+
+      def erase_line(sequence)
+        case parameter(sequence, default: 0)
+        when 1
+          fill_to_cursor
+          0.upto(@cursor) { |index| @cells[index] = " " }
+        when 2
+          @cells.clear
+        else
+          @cells.slice!(@cursor..) if @cursor < @cells.length
+        end
+      end
+
+      def parameter(sequence, default:)
+        value = sequence[2...-1].to_s.split(";", 2).first.to_s
+        value.empty? ? default : value.to_i
+      end
+
+      def write_text(text)
+        text.each_char do |character|
+          case character
+          when "\r"
+            @cursor = 0
+          when "\b"
+            @cursor = [@cursor - 1, 0].max
+          when "\t"
+            @cursor = ((@cursor / 8) + 1) * 8
+          else
+            fill_to_cursor
+            @cells[@cursor] = character
+            @cursor += 1
+          end
+        end
+      end
+
+      def fill_to_cursor
+        @cells.concat([" "] * (@cursor - @cells.length)) if @cursor > @cells.length
+      end
+    end
+  end
+end

data/lib/kward/rpc/server.rb

@@ -579,6 +579,7 @@ module Kward
           stability: { protocol: "stable", compatibility: "additive-fields-unless-protocol-version-changes", experimentalCapabilities: [] },
           commands: { supported: true, methods: COMMAND_METHODS, method: COMMAND_METHODS[0], runMethod: COMMAND_METHODS[1], sources: ["builtin", "prompt", "skill", "plugin"], executableSources: ["builtin", "plugin"] },
           skillCapture: { supported: true, methods: SKILL_CAPTURE_METHODS, destination: "personal", source: "savedSessionActiveLeaf", reviewRequired: true, overwrite: "explicit", autoActivate: false },
+          projectSkillTrust: { supported: false, trustRequired: true, reason: "RPC has no interactive trust decision bridge; project skills remain skipped unless globally enabled." },
           mcp: {
             supported: true,
             transport: "stdio",

data/lib/kward/session_catalog.rb

@@ -0,0 +1,87 @@
+require "json"
+require_relative "private_file"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Rebuildable lightweight summaries for persisted session event logs.
+  #
+  # Session JSONL files remain authoritative. Catalog entries are accepted only
+  # while their source fingerprint matches and may be deleted at any time.
+  class SessionCatalog
+    VERSION = 1
+    INDEX_DIRECTORY = ".index"
+    FILENAME = "sessions.json"
+
+    def initialize(session_dir:)
+      @path = File.join(session_dir, INDEX_DIRECTORY, FILENAME)
+      @entries = load_entries
+      @dirty = false
+    end
+
+    def fetch(path)
+      entry = @entries[entry_key(path)]
+      return nil unless entry.is_a?(Hash)
+      return nil unless entry["source"] == fingerprint(path)
+
+      entry["summary"] if entry["summary"].is_a?(Hash)
+    rescue StandardError
+      nil
+    end
+
+    def write(path, summary, fingerprint: self.fingerprint(path))
+      @entries[entry_key(path)] = {
+        "source" => fingerprint,
+        "summary" => summary
+      }
+      @dirty = true
+    end
+
+    def remove(path)
+      @dirty = true if @entries.delete(entry_key(path))
+    end
+
+    def retain(paths)
+      keys = paths.to_h { |path| [entry_key(path), true] }
+      previous_size = @entries.size
+      @entries.delete_if { |key, _entry| !keys[key] }
+      @dirty = true if @entries.size != previous_size
+    end
+
+    def flush
+      return unless @dirty
+
+      PrivateFile.write_json(@path, {
+        "version" => VERSION,
+        "entries" => @entries
+      })
+      @dirty = false
+    rescue StandardError
+      nil
+    end
+
+    def fingerprint(path)
+      stat = File.stat(path)
+      {
+        "size" => stat.size,
+        "inode" => stat.ino,
+        "mtimeSeconds" => stat.mtime.to_i,
+        "mtimeNanoseconds" => stat.mtime.nsec
+      }
+    end
+
+    private
+
+    def load_entries
+      data = JSON.parse(File.read(@path))
+      return {} unless data["version"] == VERSION && data["entries"].is_a?(Hash)
+
+      data["entries"]
+    rescue StandardError
+      {}
+    end
+
+    def entry_key(path)
+      File.basename(path)
+    end
+  end
+end

data/lib/kward/session_store.rb

@@ -9,6 +9,7 @@ require_relative "message_access"
 require_relative "message_text"
 require_relative "private_file"
 require_relative "rpc/tool_event_normalizer"
+require_relative "session_catalog"
 require_relative "tools/tool_call"
 require_relative "workspace"
 
@@ -204,6 +205,7 @@ module Kward
     def initialize(config_dir: ConfigFiles.config_dir, cwd: Dir.pwd)
       @config_dir = config_dir
       @cwd = File.expand_path(cwd)
+      @session_catalog = SessionCatalog.new(session_dir: session_dir)
     end
 
     # @return [String] workspace directory this store lists and creates sessions for
@@ -297,7 +299,7 @@ module Kward
     # `workspace` is used both for the active root and to restore read-before-write
     # paths from successful read tool results. If a session moved workspaces, load
     # it through `session_location` first so the original cwd is respected.
-    def load(path, workspace: Workspace.new, provider: nil, model: nil, reasoning_effort: nil)
+    def load(path, workspace: Workspace.new, provider: nil, model: nil, reasoning_effort: nil, project_skill_paths: nil)
       resolved_path = resolve_session_path(path)
       records = records_from_file(resolved_path)
       header = session_header(records, resolved_path)
@@ -317,7 +319,8 @@ module Kward
         model: runtime["model"] || model,
         reasoning_effort: runtime["reasoningEffort"] || reasoning_effort,
         session_memories: memory_state["sessionMemories"],
-        last_memory_retrieval: memory_state["lastRetrieval"]
+        last_memory_retrieval: memory_state["lastRetrieval"],
+        project_skill_paths: project_skill_paths
       )
       restore_tool_output_artifacts(records, conversation)
       conversation.mark_last_entry_compaction! if latest_record_type(records) == "compaction"
@@ -398,6 +401,8 @@ module Kward
       return false unless unused_session_file?(path)
 
       File.delete(path)
+      @session_catalog.remove(path)
+      @session_catalog.flush
       true
     rescue StandardError
       false
@@ -848,21 +853,43 @@ module Kward
       keep_empty_paths = Array(keep_empty_path).filter_map do |path|
         File.expand_path(path) unless path.to_s.empty?
       end
-      paths = Dir.glob(File.join(session_dir, "*.jsonl")).sort_by { |path| session_file_activity_time(path) }.reverse
-      sessions = []
+      paths = Dir.glob(File.join(session_dir, "*.jsonl"))
+      @session_catalog.retain(paths)
+      return all_recent_sessions(paths, keep_empty_paths: keep_empty_paths) if limit.nil?
+
+      candidates = paths.map do |path|
+        info = cataloged_session_info(path)
+        [path, info, info&.modified_at || session_file_activity_time(path)]
+      end
+      candidates.sort_by! { |_path, _info, modified_at| modified_at }.reverse!
 
-      paths.each do |path|
-        if limit.nil? || sessions.length < limit
-          info = session_info(path)
+      sessions = []
+      candidates.each do |path, cataloged_info, _modified_at|
+        if sessions.length < limit
+          info = cataloged_info || cache_session_info(path)
           next unless info
           next if delete_empty_unnamed_session_info(info, keep_empty_paths: keep_empty_paths)
 
           sessions << info
+        elsif cataloged_info
+          delete_empty_unnamed_session_info(cataloged_info, keep_empty_paths: keep_empty_paths)
         else
           delete_empty_unnamed_session_path(path, keep_empty_paths: keep_empty_paths)
         end
       end
       sessions
+    ensure
+      @session_catalog.flush
+    end
+
+    def all_recent_sessions(paths, keep_empty_paths:)
+      paths.filter_map do |path|
+        info = cataloged_session_info(path) || cache_session_info(path)
+        next unless info
+        next if delete_empty_unnamed_session_info(info, keep_empty_paths: keep_empty_paths)
+
+        info
+      end.sort_by(&:modified_at).reverse
     end
 
     def delete_empty_unnamed_session_info(info, keep_empty_paths: [])
@@ -870,6 +897,7 @@ module Kward
       return true if keep_empty_paths.include?(File.expand_path(info.path))
 
       File.delete(info.path)
+      @session_catalog.remove(info.path)
       true
     rescue StandardError
       false
@@ -894,6 +922,7 @@ module Kward
       return true if keep_empty_paths.include?(File.expand_path(path))
 
       File.delete(path)
+      @session_catalog.remove(path)
       true
     rescue StandardError
       false
@@ -943,6 +972,67 @@ module Kward
       end
     end
 
+    def cataloged_session_info(path)
+      summary = @session_catalog.fetch(path)
+      session_info_from_summary(path, summary) if summary
+    end
+
+    def cache_session_info(path)
+      fingerprint = @session_catalog.fingerprint(path)
+      info = session_info(path)
+      return nil unless info
+
+      current_fingerprint = @session_catalog.fingerprint(path)
+      if fingerprint == current_fingerprint
+        @session_catalog.write(path, session_info_summary(info), fingerprint: current_fingerprint)
+      end
+      info
+    rescue StandardError
+      nil
+    end
+
+    def session_info_summary(info)
+      {
+        "id" => info.id,
+        "cwd" => info.cwd,
+        "createdAt" => info.created_at.utc.iso8601(9),
+        "modifiedAt" => info.modified_at.utc.iso8601(9),
+        "name" => info.name,
+        "firstMessage" => info.first_message,
+        "messageCount" => info.message_count,
+        "provider" => info.provider,
+        "model" => info.model,
+        "reasoningEffort" => info.reasoning_effort,
+        "parentId" => info.parent_id,
+        "parentPath" => info.parent_path
+      }
+    end
+
+    def session_info_from_summary(path, summary)
+      created_at = parse_time(summary["createdAt"])
+      modified_at = parse_time(summary["modifiedAt"])
+      return nil if summary["id"].to_s.empty? || !created_at || !modified_at
+
+      SessionInfo.new(
+        id: summary["id"],
+        path: path,
+        cwd: summary["cwd"].to_s,
+        created_at: created_at,
+        modified_at: modified_at,
+        name: summary["name"],
+        first_message: summary["firstMessage"].to_s,
+        message_count: summary["messageCount"].to_i,
+        provider: summary["provider"],
+        model: summary["model"],
+        reasoning_effort: summary["reasoningEffort"],
+        parent_id: summary["parentId"],
+        parent_path: summary["parentPath"],
+        depth: 0,
+        is_last: true,
+        ancestor_continues: []
+      )
+    end
+
     def session_info(path)
       records = records_from_file(path)
       header = session_header(records, path)

data/lib/kward/skills/registry.rb

@@ -1,4 +1,5 @@
 require "pathname"
+require_relative "trust_store"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -13,8 +14,9 @@ module Kward
     # @api public
     class Registry
       SkillSource = Struct.new(:root, :label, :scope, :precedence, keyword_init: true)
+      SkillCandidate = Struct.new(:path, :root, :label, :scope, :digest, keyword_init: true)
 
-      def initialize(config_dir:, workspace_root:, project_skills_trusted:, skill_class:, max_file_bytes:, markdown_parser:, inside_directory:, warning_sink: nil)
+      def initialize(config_dir:, workspace_root:, project_skills_trusted:, skill_class:, max_file_bytes:, markdown_parser:, inside_directory:, warning_sink: nil, project_skill_paths: nil)
         @config_dir = config_dir
         @workspace_root = workspace_root
         @project_skills_trusted = project_skills_trusted
@@ -23,6 +25,32 @@ module Kward
         @markdown_parser = markdown_parser
         @inside_directory = inside_directory
         @warning_sink = warning_sink
+        @project_skill_paths = project_skill_paths&.map do |path|
+          File.realpath(path)
+        rescue SystemCallError
+          File.expand_path(path)
+        end
+      end
+
+      # Returns project skill files without activating their instructions.
+      #
+      # @return [Array<SkillCandidate>]
+      # @api public
+      def project_skill_candidates
+        skill_sources.select { |source| source.scope == :project }.flat_map do |source|
+          discover_source(source).filter_map do |path|
+            SkillCandidate.new(
+              path: path,
+              root: source.root,
+              label: source.label,
+              scope: source.scope,
+              digest: skill_digest(path)
+            )
+          rescue StandardError => e
+            emit_warning "Warning: skipping Kward skill #{path}: #{e.message}"
+            nil
+          end
+        end
       end
 
       # Returns discovered, validated skills in precedence order.
@@ -99,17 +127,39 @@ module Kward
 
       def scan_source(source)
         return [] unless Dir.exist?(source.root)
-        if source.scope == :project && !@project_skills_trusted
+        if source.scope == :project && @project_skill_paths.nil? && !@project_skills_trusted
           emit_warning "Warning: skipping #{source.label} in #{source.root}: project skills are not trusted"
           return []
         end
 
+        paths = discover_source(source)
+        return paths unless source.scope == :project && @project_skill_paths
+
+        paths.select { |path| @project_skill_paths.include?(canonical_path(path)) }
+      end
+
+      def canonical_path(path)
+        File.realpath(path)
+      rescue SystemCallError
+        File.expand_path(path)
+      end
+
+      def discover_source(source)
         Dir.glob(File.join(source.root, "*", "SKILL.md")).sort
       rescue StandardError => e
         emit_warning "Warning: skipping #{source.label} in #{source.root}: #{e.message}"
         []
       end
 
+      def skill_digest(path)
+        TrustStore.digest_files(skill_files(path), root: @workspace_root)
+      end
+
+      def skill_files(path)
+        folder = File.dirname(path)
+        [path] + skill_resources(folder).map { |resource| File.join(folder, resource) }
+      end
+
       def skill_content(skill, content)
         lines = [
           %(<skill_content name="#{xml_escape(skill.name)}">),

data/lib/kward/skills/trust_coordinator.rb

@@ -0,0 +1,45 @@
+require_relative "trust_store"
+
+# Namespace for Agent Skills discovery and trust management.
+module Kward
+  module Skills
+    # Resolves which discovered project skills need a user decision.
+    class TrustCoordinator
+      def initialize(workspace_root:, trust_store:)
+        @workspace_root = workspace_root
+        @trust_store = trust_store
+      end
+
+      def decision(candidate)
+        @trust_store.decision(
+          workspace_root: @workspace_root,
+          skill_path: candidate.path,
+          digest: candidate.digest
+        )
+      end
+
+      def pending(candidates)
+        candidates.reject { |candidate| decision(candidate) }
+      end
+
+      def allowed_paths(candidates)
+        candidates.filter_map { |candidate| candidate.path if decision(candidate) == "allow" }
+      end
+
+      def remove_workspace!
+        @trust_store.remove_workspace!(workspace_root: @workspace_root)
+      end
+
+      def record!(candidates, decision)
+        candidates.each do |candidate|
+          @trust_store.set_decision!(
+            workspace_root: @workspace_root,
+            skill_path: candidate.path,
+            digest: candidate.digest,
+            decision: decision
+          )
+        end
+      end
+    end
+  end
+end

data/lib/kward/skills/trust_store.rb

@@ -0,0 +1,107 @@
+require "digest"
+require "json"
+require "pathname"
+require_relative "../path_guard"
+require_relative "../private_file"
+
+# Namespace for Agent Skills discovery and trust management.
+module Kward
+  module Skills
+    # Persists workspace-scoped decisions for project skill snapshots.
+    class TrustStore
+      DECISIONS = %w[allow deny].freeze
+
+      attr_reader :path
+
+      def initialize(config_dir:)
+        @path = File.join(File.expand_path(config_dir), "trusted_project_skills.json")
+      end
+
+      def decision(workspace_root:, skill_path:, digest:)
+        record = skill_record(workspace_root: workspace_root, skill_path: skill_path)
+        return unless record
+        return unless record["digest"] == digest.to_s
+
+        decision = record["decision"]
+        decision if DECISIONS.include?(decision)
+      end
+
+      def set_decision!(workspace_root:, skill_path:, digest:, decision:)
+        decision = decision.to_s
+        raise ArgumentError, "invalid project skill trust decision: #{decision}" unless DECISIONS.include?(decision)
+
+        config = read_config
+        workspace = workspace_key(workspace_root)
+        skill = skill_key(workspace_root, skill_path)
+        config["workspaces"] ||= {}
+        config["workspaces"][workspace] ||= { "skills" => {} }
+        config["workspaces"][workspace]["skills"] ||= {}
+        config["workspaces"][workspace]["skills"][skill] = {
+          "digest" => digest.to_s,
+          "decision" => decision
+        }
+        PrivateFile.write_json(path, config)
+      end
+
+      def remove_workspace!(workspace_root:)
+        config = read_config
+        config.fetch("workspaces", {}).delete(workspace_key(workspace_root))
+        PrivateFile.write_json(path, config)
+      end
+
+      def remove_skill!(workspace_root:, skill_path:)
+        config = read_config
+        workspace = config.fetch("workspaces", {})[workspace_key(workspace_root)]
+        workspace&.fetch("skills", {})&.delete(skill_key(workspace_root, skill_path))
+        PrivateFile.write_json(path, config)
+      end
+
+      def self.digest_files(paths, root: nil)
+        root = File.realpath(root) if root
+        digest = Digest::SHA256.new
+        paths.map { |path| File.realpath(path) }.sort.each do |path|
+          raise ArgumentError, "file is outside digest root" if root && !PathGuard.inside?(path, root)
+
+          relative_path = root ? Pathname.new(path).relative_path_from(Pathname.new(root)).to_s : path
+          digest.update(relative_path)
+          digest.update("\0")
+          digest.update(File.binread(path))
+          digest.update("\0")
+        end
+        digest.hexdigest
+      end
+
+      private
+
+      def skill_record(workspace_root:, skill_path:)
+        workspace = read_config.fetch("workspaces", {})[workspace_key(workspace_root)]
+        workspace&.fetch("skills", {})&.[](skill_key(workspace_root, skill_path))
+      end
+
+      def read_config
+        return {} unless File.file?(path)
+
+        config = JSON.parse(File.read(path))
+        config.is_a?(Hash) ? config : {}
+      rescue JSON::ParserError, SystemCallError
+        {}
+      end
+
+      def workspace_key(workspace_root)
+        File.realpath(workspace_root)
+      rescue SystemCallError
+        File.expand_path(workspace_root)
+      end
+
+      def skill_key(workspace_root, skill_path)
+        workspace = workspace_key(workspace_root)
+        skill = File.realpath(skill_path)
+        raise ArgumentError, "project skill is outside workspace" unless PathGuard.inside?(skill, workspace)
+
+        Pathname.new(skill).relative_path_from(Pathname.new(workspace)).to_s
+      rescue SystemCallError
+        raise ArgumentError, "project skill path does not exist"
+      end
+    end
+  end
+end