kward 0.83.0 → 0.84.0

data/lib/kward/scratchpad_runner.rb

@@ -1,56 +1,182 @@
 require "open3"
 require "rbconfig"
 require "tempfile"
+require_relative "scratchpad_languages"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
-  # Executes scratchpad buffers and returns transformed buffer content.
+  # Executes editor buffers and returns captured runner output.
   module ScratchpadRunner
-    RUBY_END_MARKER_PATTERN = /^__END__\n?/.freeze
+    OUTPUT_READ_SIZE = 16 * 1024
+    MAX_OUTPUT_BYTES = 1_000_000
+    POLL_INTERVAL = 0.05
 
-    Result = Struct.new(:buffer, :exit_status, keyword_init: true)
+    DEFAULT_BINARIES = {
+      ruby: -> { RbConfig.ruby },
+      node: "node",
+      python: -> { windows_host? ? "python" : "python3" },
+      shell: -> { File.executable?("/bin/sh") ? "/bin/sh" : "sh" },
+      lua: "lua",
+      julia: "julia",
+      elixir: "elixir",
+      crystal: "crystal",
+      swift: "swift",
+      go: "go"
+    }.freeze
+    RUNNER_ARGUMENTS = {
+      crystal: ["run"],
+      go: ["run"]
+    }.freeze
+
+    Result = Struct.new(:language, :output, :exit_status, :duration, :command, :cancelled, :truncated, keyword_init: true)
 
     module_function
 
-    def run(language, content)
-      case language&.to_sym
-      when :ruby
-        run_ruby(content)
-      else
-        raise ArgumentError, "Scratchpad language #{language.inspect} is not runnable"
+    def run(language, content, cancelled: nil, cwd: Dir.pwd, source_path: nil, runner_config: {})
+      language = ScratchpadLanguages.normalize(language)
+      runner = ScratchpadLanguages.runner(language)
+      raise ArgumentError, "Scratchpad language #{language.inspect} is not runnable" unless runner
+
+      cwd = File.expand_path(cwd.to_s.empty? ? Dir.pwd : cwd)
+      binary = configured_binary(runner, runner_config, cwd)
+      arguments = RUNNER_ARGUMENTS.fetch(runner, [])
+      default_display_path = ScratchpadLanguages.display_path(language)
+      display_path = source_path.to_s.empty? ? default_display_path : File.basename(source_path.to_s)
+      extension = File.extname(display_path)
+      extension = File.extname(default_display_path) if extension.empty?
+      started_at = monotonic_now
+      output, status, was_cancelled, truncated = capture_source(
+        content,
+        extension: extension,
+        source_path: source_path,
+        cwd: cwd,
+        command: [binary, *arguments],
+        cancelled: cancelled
+      )
+      Result.new(
+        language: language,
+        output: output,
+        exit_status: was_cancelled ? 130 : status.exitstatus,
+        duration: monotonic_now - started_at,
+        command: [binary, *arguments, "<#{display_path}>"],
+        cancelled: was_cancelled,
+        truncated: truncated
+      )
+    rescue Errno::ENOENT
+      raise ArgumentError, "Editor runner #{runner.inspect} binary #{binary.inspect} was not found"
+    rescue Errno::EACCES
+      raise ArgumentError, "Editor runner #{runner.inspect} binary #{binary.inspect} is not executable"
+    end
+
+    def capture_source(content, extension:, source_path:, cwd:, command:, cancelled: nil)
+      Tempfile.create(["kward-scratchpad", extension], dir: temporary_directory(cwd, source_path)) do |file|
+        file.write(content.to_s)
+        file.flush
+        capture_process([*command, file.path], cancelled: cancelled, chdir: cwd)
       end
     end
 
-    def run_ruby(content)
-      content = content.to_s
-      output, status = capture_ruby_output(content)
-      Result.new(buffer: ruby_buffer_with_output(content, output, status.exitstatus), exit_status: status.exitstatus)
+    def configured_binary(runner, runner_config, cwd)
+      settings = runner_config.is_a?(Hash) ? (runner_config[runner.to_s] || runner_config[runner]) : nil
+      configured = settings.is_a?(Hash) ? (settings["binary"] || settings[:binary]) : settings
+      binary = configured.nil? ? default_binary(runner) : configured
+      unless binary.is_a?(String) && !binary.strip.empty?
+        raise ArgumentError, "Editor runner #{runner.inspect} binary must be a non-empty string"
+      end
+
+      binary = binary.strip
+      path_like?(binary) ? File.expand_path(binary, cwd) : binary
     end
 
-    def capture_ruby_output(content)
-      Tempfile.create(["kward-scratchpad", ".rb"]) do |file|
-        file.write(content)
-        file.flush
-        Open3.capture2e(RbConfig.ruby, file.path)
+    def default_binary(runner)
+      value = DEFAULT_BINARIES[runner]
+      value.respond_to?(:call) ? value.call : value
+    end
+
+    def temporary_directory(cwd, source_path)
+      return cwd if source_path.to_s.empty?
+
+      directory = File.dirname(File.expand_path(source_path, cwd))
+      return directory if Dir.exist?(directory) && File.writable?(directory)
+
+      cwd
+    end
+
+    def path_like?(value)
+      value.include?("/") || value.include?("\\") || value.start_with?("~")
+    end
+
+    def windows_host?
+      RbConfig::CONFIG["host_os"].to_s.match?(/mswin|mingw|cygwin/i)
+    end
+
+    def capture_process(command, cancelled: nil, chdir: nil)
+      options = chdir ? { chdir: chdir } : {}
+      input, output, wait_thread = Open3.popen2e(*command, **options)
+      input.close
+      chunks = []
+      output_size = 0
+      was_cancelled = false
+
+      loop do
+        if !was_cancelled && cancelled&.call
+          terminate_process(wait_thread.pid)
+          was_cancelled = true
+        end
+
+        output_size = read_available_output(output, chunks, output_size)
+        break if wait_thread.join(0)
+
+        sleep POLL_INTERVAL
+      end
+
+      output_size = read_remaining_output(output, chunks, output_size)
+      [chunks.join, wait_thread.value, was_cancelled, output_size >= MAX_OUTPUT_BYTES]
+    ensure
+      if wait_thread&.alive?
+        terminate_process(wait_thread.pid)
+        wait_thread.join
       end
+      input&.close unless input&.closed?
+      output&.close unless output&.closed?
     end
 
-    def ruby_buffer_with_output(content, output, exit_status)
-      output = output.to_s
-      output += "\n" unless output.empty? || output.end_with?("\n")
-      output += "[exit status: #{exit_status}]\n" unless exit_status.to_i.zero?
+    def read_available_output(output, chunks, output_size)
+      ready = IO.select([output], nil, nil, 0)
+      return output_size unless ready
 
-      if (match = content.match(RUBY_END_MARKER_PATTERN))
-        "#{content[0...match.begin(0)]}__END__\n#{output}"
-      else
-        "#{content}#{ruby_end_separator(content)}__END__\n#{output}"
+      loop do
+        output_size = append_output(chunks, output.read_nonblock(OUTPUT_READ_SIZE), output_size)
+      rescue IO::WaitReadable, EOFError
+        break
       end
+      output_size
     end
 
-    def ruby_end_separator(content)
-      return "" if content.empty?
+    def read_remaining_output(output, chunks, output_size)
+      loop do
+        output_size = append_output(chunks, output.read_nonblock(OUTPUT_READ_SIZE), output_size)
+      end
+    rescue IO::WaitReadable, IOError, EOFError
+      output_size
+    end
+
+    def append_output(chunks, chunk, output_size)
+      return output_size if output_size >= MAX_OUTPUT_BYTES
+
+      remaining = MAX_OUTPUT_BYTES - output_size
+      chunks << chunk.byteslice(0, remaining)
+      output_size + [chunk.bytesize, remaining].min
+    end
+
+    def terminate_process(pid)
+      Process.kill("TERM", pid)
+    rescue Errno::ESRCH
+      nil
+    end
 
-      content.end_with?("\n") ? "\n" : "\n\n"
+    def monotonic_now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
   end
 end

data/lib/kward/shell_prompt.rb

@@ -16,6 +16,8 @@ module Kward
 
           Use prepare_shell_command when the user asks you to suggest or prepare a command. It places the complete command in the shell prompt but does not execute it; the user must press Enter. Never claim that a prepared command was executed.
 
+          When available, use open_editor if the user explicitly asks to open an existing workspace file in Kward's integrated editor. Opening the editor does not modify or save the file.
+
           Do not execute interactive commands, request passwords, or silently run commands that the user did not explicitly request. If a command needs terminal input, prepare it for the user instead.
         PROMPT
       }

data/lib/kward/terminal_keys.rb

@@ -9,6 +9,8 @@ module Kward
     CTRL_D = "\x04".freeze
     CTRL_E = "\x05".freeze
     CTRL_F = "\x06".freeze
+    CTRL_H = "\x08".freeze
+    CTRL_J = "\x0A".freeze
     CTRL_K = "\x0B".freeze
     CTRL_L = "\x0C".freeze
     CTRL_N = "\x0E".freeze
@@ -71,6 +73,16 @@ module Kward
     CTRL_T_CSI_U = "\e[116;5u".freeze
     CTRL_W_CSI_U = "\e[119;5u".freeze
     CTRL_NUMBER_TAB_PATTERN = /\A\e\[((?:49)|(?:5[0-7]));5u\z/.freeze
+    TAB_ACTION_SEQUENCES = (
+      CTRL_TAB +
+      CTRL_SHIFT_TAB +
+      [CTRL_T, CTRL_T_CSI_U, CTRL_W_CSI_U] +
+      (49..57).map { |code| "\e[#{code};5u" } +
+      ["\et", "\eT"] +
+      ALT_RIGHT +
+      ALT_LEFT +
+      (1..9).map { |number| "\e#{number}" }
+    ).freeze
 
     CSI_U_PATTERN = /\A\e\[(\d+)((?:;[\d:]*)*)u/.freeze
     MODIFIED_CURSOR_PATTERN = /\A\e\[(\d+);(\d+)([CDFH])\z/.freeze

data/lib/kward/terminal_text.rb

@@ -0,0 +1,121 @@
+require "unicode/display_width"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Terminal-cell and grapheme helpers for cursor-aware text layout.
+  module TerminalText
+    module_function
+
+    def width(text)
+      Unicode::DisplayWidth.of(text.to_s, ambiguous: 1, emoji: :all)
+    end
+
+    def truncate(text, max_width)
+      string = text.to_s
+      limit = [max_width.to_i, 0].max
+      return string[0, limit].to_s if string.ascii_only?
+
+      remaining = limit
+      truncated = +""
+      string.each_grapheme_cluster do |grapheme|
+        grapheme_width = width(grapheme)
+        break if grapheme_width > remaining
+
+        truncated << grapheme
+        remaining -= grapheme_width
+      end
+      truncated
+    end
+
+    def wrap(text, width:, cursor: nil)
+      string = text.to_s
+      line_width = [width.to_i, 1].max
+      return wrap_ascii(string, line_width, cursor) if string.ascii_only?
+
+      rows = [+""]
+      row_widths = [0]
+      cursor_row = nil
+      cursor_col = nil
+      offset = 0
+
+      string.each_grapheme_cluster do |grapheme|
+        if !cursor.nil? && cursor_row.nil? && cursor <= offset
+          append_empty_row(rows, row_widths) if row_widths.last >= line_width
+          cursor_row = rows.length - 1
+          cursor_col = row_widths.last
+        end
+
+        grapheme_width = width(grapheme)
+        append_empty_row(rows, row_widths) if row_widths.last.positive? && row_widths.last + grapheme_width > line_width
+        rows.last << grapheme
+        row_widths[-1] += grapheme_width
+        offset += grapheme.length
+
+        if !cursor.nil? && cursor_row.nil? && cursor <= offset
+          cursor_row = rows.length - 1
+          cursor_col = row_widths.last
+        end
+      end
+
+      if !cursor.nil? && cursor_row.nil?
+        append_empty_row(rows, row_widths) if row_widths.last >= line_width
+        cursor_row = rows.length - 1
+        cursor_col = row_widths.last
+      elsif !cursor.nil? && cursor >= offset && row_widths.last >= line_width
+        append_empty_row(rows, row_widths)
+        cursor_row = rows.length - 1
+        cursor_col = 0
+      end
+
+      { rows: rows, cursor_row: cursor_row, cursor_col: cursor_col }
+    end
+
+    def previous_grapheme_boundary(text, index)
+      string = text.to_s
+      cursor = [[index.to_i, 0].max, string.length].min
+      return [cursor - 1, 0].max if string.ascii_only?
+
+      previous = 0
+      offset = 0
+      string.each_grapheme_cluster do |grapheme|
+        offset += grapheme.length
+        return previous if offset >= cursor
+
+        previous = offset
+      end
+      previous
+    end
+
+    def next_grapheme_boundary(text, index)
+      string = text.to_s
+      cursor = [[index.to_i, 0].max, string.length].min
+      return [cursor + 1, string.length].min if string.ascii_only?
+
+      offset = 0
+      string.each_grapheme_cluster do |grapheme|
+        offset += grapheme.length
+        return offset if offset > cursor
+      end
+      string.length
+    end
+
+    def wrap_ascii(text, line_width, cursor)
+      rows = text.scan(/.{1,#{line_width}}/m)
+      rows = [""] if rows.empty?
+      return { rows: rows, cursor_row: nil, cursor_col: nil } if cursor.nil?
+
+      cursor = [[cursor.to_i, 0].max, text.length].min
+      if cursor == text.length && text.length.positive? && (text.length % line_width).zero?
+        rows << ""
+      end
+      { rows: rows, cursor_row: cursor / line_width, cursor_col: cursor % line_width }
+    end
+    private_class_method :wrap_ascii
+
+    def append_empty_row(rows, row_widths)
+      rows << +""
+      row_widths << 0
+    end
+    private_class_method :append_empty_row
+  end
+end

data/lib/kward/text_matcher.rb

@@ -0,0 +1,18 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Allocation-conscious text matching helpers shared by interactive search UI.
+  module TextMatcher
+    module_function
+
+    def subsequence_pattern(query)
+      source = query.to_s.each_char.map { |character| Regexp.escape(character) }.join(".*")
+      Regexp.new(source, Regexp::MULTILINE)
+    end
+
+    def subsequence?(value, query, pattern = subsequence_pattern(query))
+      text = value.to_s
+      needle = query.to_s
+      needle.empty? || text.match?(pattern)
+    end
+  end
+end

data/lib/kward/tools/open_editor.rb

@@ -0,0 +1,41 @@
+require_relative "base"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Model-callable tool wrappers and their argument schemas.
+  module Tools
+    # Tool wrapper for opening a workspace file in the integrated editor.
+    class OpenEditor < Base
+      # Builds the tool schema and stores the execution dependencies.
+      def initialize(workspace:, prompt:)
+        @workspace = workspace
+        @prompt = prompt
+        super(
+          "open_editor",
+          "Open a workspace file in Kward's integrated editor for the user. Use this when the user explicitly asks to open or edit a file in the built-in editor. This does not itself modify or save the file; the user controls those actions in the editor.",
+          properties: {
+            path: { type: "string", description: "Workspace-relative path of the file to open." }
+          },
+          required: ["path"]
+        )
+      end
+
+      # Opens the requested file and returns after the editor closes.
+      def call(args, _conversation, cancellation: nil)
+        cancellation&.raise_if_cancelled!
+        return "Error: open_editor requires interactive editor support." unless @prompt.respond_to?(:edit_file)
+
+        path = argument(args, :path, "").to_s
+        return "Error: open_editor requires a file path." if path.empty?
+
+        resolved_path = @workspace.resolved_path(path)
+        return "Error: not a file: #{path}" unless File.file?(resolved_path)
+
+        opened = @prompt.edit_file(resolved_path, base_dir: @workspace.root, allow_new: false)
+        opened ? "Opened #{path} in the integrated editor." : "Error: could not open #{path} in the integrated editor."
+      rescue SecurityError, StandardError => e
+        "Error: could not open #{path}: #{e.message}"
+      end
+    end
+  end
+end

data/lib/kward/tools/registry.rb

@@ -19,6 +19,7 @@ require_relative "summarize_file_structure"
 require_relative "retrieve_tool_output"
 require_relative "web_search"
 require_relative "write_file"
+require_relative "open_editor"
 require_relative "replace_editor_buffer"
 require_relative "search/code"
 require_relative "search/web"
@@ -73,8 +74,8 @@ module Kward
     # Builds tool objects and the schema list for the current frontend/config.
     #
     # @param workspace [Workspace] filesystem/shell boundary used by local tools
-    # @param prompt [Object, nil] interactive prompt bridge; must implement
-    #   `ask_user_question` before that tool is advertised
+    # @param prompt [Object, nil] interactive prompt bridge; tools such as
+    #   `ask_user_question` and `open_editor` are advertised only when supported
     # @param web_search [WebSearch] live web search implementation
     # @param web_fetch [WebFetch] specific URL fetch implementation
     # @param code_search [CodeSearch] public source/package search implementation
@@ -257,7 +258,7 @@ module Kward
         "web"
       when Tools::ReadSkill
         "skill"
-      when Tools::AskUserQuestion
+      when Tools::AskUserQuestion, Tools::OpenEditor
         "ui"
       else
         "builtin"
@@ -522,6 +523,7 @@ module Kward
     def build_schema_tools
       tools = @tools.values_at(*CORE_TOOL_NAMES)
       tools << @tools["replace_editor_buffer"] if @tools["replace_editor_buffer"]
+      tools << @tools["open_editor"] if @tools["open_editor"]
       tools << @tools["prepare_shell_command"] if @tools["prepare_shell_command"]
       tools << @tools["git_commit"] if @tools["git_commit"]
       tools.concat(@tools.values_at("web_search", "fetch_content", "fetch_raw")) if web_search_available?
@@ -557,6 +559,7 @@ module Kward
         Tools::RetrieveToolOutput.new
       ]
       tools << Tools::ReplaceEditorBuffer.new(editor_prompt_session: @editor_prompt_session) if @editor_prompt_session
+      tools << Tools::OpenEditor.new(workspace: @workspace, prompt: @prompt) if editor_available?
       tools << Tools::PrepareShellCommand.new(shell_prompt_session: @shell_prompt_session) if @shell_prompt_session
       tools
     end
@@ -569,6 +572,10 @@ module Kward
       end
     end
 
+    def editor_available?
+      @prompt&.respond_to?(:edit_file)
+    end
+
     def editor_prompt_tool_names
       readonly_tools = CORE_TOOL_NAMES - %w[write_file edit_file run_shell_command]
       readonly_tools + ["replace_editor_buffer"]
@@ -576,7 +583,9 @@ module Kward
 
     def shell_prompt_tool_names
       readonly_tools = CORE_TOOL_NAMES - %w[write_file edit_file run_shell_command]
-      readonly_tools + %w[run_shell_command prepare_shell_command]
+      tools = readonly_tools + %w[run_shell_command prepare_shell_command]
+      tools << "open_editor" if editor_available?
+      tools
     end
 
     def web_search_available?

data/lib/kward/tools/tool_call.rb

@@ -26,7 +26,8 @@ module Kward
       "fetch_raw" => "fetch_raw",
       "git_commit" => "git_commit",
       "read_skill" => "read_skill",
-      "ask_user_question" => "ask_user_question"
+      "ask_user_question" => "ask_user_question",
+      "open_editor" => "open_editor"
     }.freeze
 
     module_function

data/lib/kward/version.rb

@@ -1,5 +1,5 @@
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # Current gem version.
-  VERSION = "0.83.0"
+  VERSION = "0.84.0"
 end

data/templates/default/fulldoc/html/css/kward.css

@@ -570,127 +570,6 @@ body.kward-docs #footer {
   color: var(--kward-accent-bright);
 }
 
-/*
-  Hero tagline "swosh": cycles each line through three phrases. The first
-  line moves right-to-left: "Your terminal.", "Your RPC frontend.", then
-  "Your workflow." The second line mirrors it left-to-right: "Your agent.",
-  "Your LLM engine.", then "Your harness." Pure CSS — no JS. The global
-  @media (prefers-reduced-motion) rule above collapses the animation to
-  the static original copy ("Your terminal. Your agent.") so it remains
-  accessible and calm.
-*/
-.kward-swosh {
-  box-sizing: content-box;
-  display: inline-block;
-  height: 0.98em;
-  line-height: 0.98;
-  margin: -0.16em -0.08em;
-  overflow: hidden;
-  padding: 0.16em 0.08em;
-  position: relative;
-  vertical-align: top;
-}
-
-.kward-hero h1 .kward-swosh-text {
-  color: var(--kward-ink);
-  display: inline-block;
-  line-height: 0.98;
-  white-space: nowrap;
-  will-change: transform, opacity;
-}
-
-/* The longest text ("Your RPC frontend.") stays in flow to size the box;
-   the shorter phrases overlay it absolutely. */
-.kward-swosh-text-a,
-.kward-swosh-text-e {
-  left: 0.08em;
-  position: absolute;
-  top: 0.16em;
-}
-
-.kward-swosh-text-a {
-  animation: kward-swosh-a 18s cubic-bezier(0.22, 0.61, 0.36, 1) infinite;
-}
-
-.kward-swosh-text-b {
-  animation: kward-swosh-b 18s cubic-bezier(0.22, 0.61, 0.36, 1) infinite;
-  position: relative;
-}
-
-.kward-swosh-text-e {
-  animation: kward-swosh-e 18s cubic-bezier(0.22, 0.61, 0.36, 1) infinite;
-}
-
-@keyframes kward-swosh-a {
-  0%, 25%   { transform: translateX(0);     opacity: 1; filter: none; }
-  33%       { transform: translateX(-140%); opacity: 0; filter: blur(3px); }
-  34%, 92%  { transform: translateX(140%);  opacity: 0; filter: none; }
-  100%      { transform: translateX(0);     opacity: 1; filter: none; }
-}
-
-@keyframes kward-swosh-b {
-  0%, 25%   { transform: translateX(140%);  opacity: 0; filter: none; }
-  33%       { transform: translateX(0);     opacity: 1; filter: none; }
-  58%       { transform: translateX(0);     opacity: 1; filter: none; }
-  66%       { transform: translateX(-140%); opacity: 0; filter: blur(3px); }
-  67%, 100% { transform: translateX(140%);  opacity: 0; filter: none; }
-}
-
-@keyframes kward-swosh-e {
-  0%, 58%   { transform: translateX(140%);  opacity: 0; filter: none; }
-  66%       { transform: translateX(0);     opacity: 1; filter: none; }
-  92%       { transform: translateX(0);     opacity: 1; filter: none; }
-  100%      { transform: translateX(-140%); opacity: 0; filter: blur(3px); }
-}
-
-/*
-  Second line, mirrored left-to-right. All texts keep the accent-bright
-  color of the original "Your agent." span.
-*/
-.kward-hero h1 .kward-swosh-text-c,
-.kward-hero h1 .kward-swosh-text-f {
-  color: var(--kward-accent-bright);
-  left: 0.08em;
-  position: absolute;
-  top: 0.16em;
-}
-
-.kward-hero h1 .kward-swosh-text-c {
-  animation: kward-swosh-c 18s cubic-bezier(0.22, 0.61, 0.36, 1) infinite;
-}
-
-.kward-hero h1 .kward-swosh-text-d {
-  animation: kward-swosh-d 18s cubic-bezier(0.22, 0.61, 0.36, 1) infinite;
-  color: var(--kward-accent-bright);
-  position: relative;
-}
-
-.kward-hero h1 .kward-swosh-text-f {
-  animation: kward-swosh-f 18s cubic-bezier(0.22, 0.61, 0.36, 1) infinite;
-}
-
-@keyframes kward-swosh-c {
-  0%, 25%   { transform: translateX(0);     opacity: 1; filter: none; }
-  33%       { transform: translateX(140%);  opacity: 0; filter: blur(3px); }
-  34%, 92%  { transform: translateX(-140%); opacity: 0; filter: none; }
-  100%      { transform: translateX(0);     opacity: 1; filter: none; }
-}
-
-@keyframes kward-swosh-d {
-  0%, 25%   { transform: translateX(-140%); opacity: 0; filter: none; }
-  33%       { transform: translateX(0);     opacity: 1; filter: none; }
-  58%       { transform: translateX(0);     opacity: 1; filter: none; }
-  66%       { transform: translateX(140%);  opacity: 0; filter: blur(3px); }
-  67%, 100% { transform: translateX(-140%); opacity: 0; filter: none; }
-}
-
-@keyframes kward-swosh-f {
-  0%, 58%   { transform: translateX(-140%); opacity: 0; filter: none; }
-  66%       { transform: translateX(0);     opacity: 1; filter: none; }
-  92%       { transform: translateX(0);     opacity: 1; filter: none; }
-  100%      { transform: translateX(140%);  opacity: 0; filter: blur(3px); }
-}
-
 .kward-lede {
   color: var(--kward-ink);
   font-size: 19px;
@@ -1041,10 +920,6 @@ body.kward-docs .kward-home #footer p {
     font-size: clamp(32px, 10vw, 38px);
   }
 
-  .kward-swosh {
-    max-width: 100%;
-  }
-
   .kward-feature-strip,
   .kward-capabilities ul {
     grid-template-columns: 1fr;