kward 0.82.0 → 0.84.0

data/lib/kward/ansi.rb

@@ -23,6 +23,12 @@ module Kward
       gray: 90,
       grey: 90,
       white: 97,
+      activity: 36,
+      success: 32,
+      caution: 33,
+      failure: 31,
+      tool: 35,
+      metadata: 90,
       primary_green: "38;2;138;160;106",
       bright_accent_green: "38;2;155;255;0",
       augen: "38;2;155;255;0",
@@ -181,23 +187,30 @@ module Kward
         @enabled = enabled
         @pending = +""
         @in_fence = false
+        @line_streaming = false
       end
 
       def render(delta, final: false)
-        text = delta.to_s
-        return ANSI.markdown(text, enabled: @enabled) if fast_markdown?(text, final)
-
-        @pending << text
+        @pending << delta.to_s
         rendered = +""
         while (match = @pending.match(/\r\n|\r|\n/))
           line = @pending[0...match.begin(0)]
           @pending = @pending[(match.end(0))..] || +""
-          rendered << render_line(line) << "\n"
+          rendered << render_pending_line(line) << "\n"
         end
 
-        if final && !@pending.empty?
-          rendered << render_line(@pending)
-          @pending.clear
+        if final
+          unless @pending.empty?
+            rendered << render_pending_line(@pending)
+            @pending.clear
+          end
+        else
+          streamable = streamable_inline_prefix
+          unless streamable.empty?
+            rendered << ANSI.inline_markdown(streamable, enabled: @enabled)
+            @pending = @pending[streamable.length..] || +""
+            @line_streaming = true
+          end
         end
 
         if final && @in_fence
@@ -211,8 +224,95 @@ module Kward
 
       private
 
-      def fast_markdown?(text, final)
-        !final && !@in_fence && @pending.empty? && !text.match?(/[`*~_\[\]>]/)
+      def render_pending_line(line)
+        if @line_streaming
+          @line_streaming = false
+          ANSI.inline_markdown(line, enabled: @enabled)
+        else
+          render_line(line)
+        end
+      end
+
+      def streamable_inline_prefix
+        return "" if @pending.empty? || block_line_pending?
+
+        boundary = [
+          unmatched_marker_index("`"),
+          unmatched_marker_index("**"),
+          unmatched_marker_index("~~"),
+          unmatched_emphasis_index("*"),
+          unmatched_emphasis_index("_"),
+          incomplete_marker_prefix_index,
+          incomplete_link_index
+        ].compact.min
+        boundary ? @pending[0...boundary] : @pending.dup
+      end
+
+      def unmatched_marker_index(marker)
+        unmatched = nil
+        offset = 0
+        while (index = @pending.index(marker, offset))
+          unmatched = unmatched ? nil : index
+          offset = index + marker.length
+        end
+        unmatched
+      end
+
+      def unmatched_emphasis_index(marker)
+        unmatched = nil
+        offset = 0
+        while (index = @pending.index(marker, offset))
+          previous = index.positive? ? @pending[index - 1] : nil
+          following = @pending[index + 1]
+          offset = index + 1
+          next if previous == marker || following == marker
+
+          if unmatched
+            unmatched = nil if following.nil? || following.match?(/[\s\)\]},.!?:;]/)
+          elsif previous.nil? || previous.match?(/[\s\(\[{]/)
+            unmatched = index
+          end
+        end
+        unmatched
+      end
+
+      def incomplete_marker_prefix_index
+        trailing = @pending[/~+\z/]
+        return nil unless trailing&.length&.odd?
+
+        @pending.length - 1
+      end
+
+      def incomplete_link_index
+        offset = 0
+        while (opening = @pending.index("[", offset))
+          closing = @pending.index("]", opening + 1)
+          return opening unless closing
+          return opening if closing == @pending.length - 1
+
+          unless @pending[closing + 1] == "("
+            offset = closing + 1
+            next
+          end
+
+          closing_parenthesis = @pending.index(")", closing + 2)
+          return opening unless closing_parenthesis
+
+          offset = closing_parenthesis + 1
+        end
+        nil
+      end
+
+      def block_line_pending?
+        return true if @in_fence
+        return false if @line_streaming
+
+        line = @pending.lstrip
+        line.start_with?("```") || line.match?(/\A`{1,2}\z/) ||
+          line.match?(/\A\#{1,6}(?:\s|\z)/) ||
+          line.start_with?(">") ||
+          line.match?(/\A[-*]\s+\[[ xX]\](?:\s|\z)/) ||
+          line.match?(/\A[-*](?:\s*\z|\s+\[[ xX]?\z)/)
       end
 
       def render_line(line)

data/lib/kward/auth/anthropic_oauth.rb

@@ -17,7 +17,7 @@ module Kward
     DEFAULT_PORT = 53_692
     CALLBACK_PATH = "/callback"
     DEFAULT_CLIENT_ID = Base64.decode64("OWQxYzI1MGEtZTYxYi00NGQ5LTg4ZWQtNTk0NGQxOTYyZjVl")
-    SCOPE = "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload"
+    SCOPE = "user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload"
 
     attr_reader :auth_path
 
@@ -60,7 +60,7 @@ module Kward
       end
       raise "Missing authorization code" if code.to_s.empty?
 
-      complete_login_flow(code: code, redirect_uri: redirect_uri, code_verifier: pkce[:verifier])
+      complete_login_flow(code: code, redirect_uri: redirect_uri, code_verifier: pkce[:verifier], state: state)
       auth_path
     ensure
       server&.close unless server&.closed?
@@ -68,7 +68,6 @@ module Kward
 
     def authorization_url(redirect_uri:, code_challenge:, state:)
       query = URI.encode_www_form(
-        code: "true",
         client_id: client_id,
         response_type: "code",
         redirect_uri: redirect_uri,
@@ -98,8 +97,8 @@ module Kward
       wait_for_callback(server, expected_state: expected_state, timeout_seconds: timeout_seconds)
     end
 
-    def complete_login_flow(code:, redirect_uri:, code_verifier:)
-      tokens = exchange_code_for_tokens(code: code, redirect_uri: redirect_uri, code_verifier: code_verifier)
+    def complete_login_flow(code:, redirect_uri:, code_verifier:, state:)
+      tokens = exchange_code_for_tokens(code: code, redirect_uri: redirect_uri, code_verifier: code_verifier, state: state)
       save_auth(tokens: tokens)
       tokens
     end
@@ -192,13 +191,14 @@ module Kward
       oauth_callback_server(port_env: "KWARD_ANTHROPIC_OAUTH_PORT", default_port: DEFAULT_PORT)
     end
 
-    def exchange_code_for_tokens(code:, redirect_uri:, code_verifier:)
+    def exchange_code_for_tokens(code:, redirect_uri:, code_verifier:, state:)
       response = post_json(TOKEN_URL,
         grant_type: "authorization_code",
         client_id: client_id,
         code: code,
         redirect_uri: redirect_uri,
-        code_verifier: code_verifier)
+        code_verifier: code_verifier,
+        state: state)
       parse_successful_json(response, "Anthropic OAuth token exchange")
     end
 

data/lib/kward/cli/auth_commands.rb

@@ -13,6 +13,8 @@ module Kward
         case arguments
         when ["status"]
           print_auth_status
+        when ["status", "--all"]
+          print_auth_status(show_all: true)
         when ["logout"]
           logout_auth
         else
@@ -21,23 +23,42 @@ module Kward
       end
 
       # Writes the auth status output for the terminal CLI flow.
-      def print_auth_status
-        store = api_key_store
-        store.migrate_openrouter_config_key!
-        lines = ["#{colored("Auth Status", :green, :bold)}", ""]
-        lines << auth_status_line("OpenAI OAuth", File.exist?(OpenAIOAuth.default_auth_path), OpenAIOAuth.default_auth_path)
-        lines << auth_status_line("Anthropic OAuth", File.exist?(AnthropicOAuth.default_auth_path), AnthropicOAuth.default_auth_path)
-        lines << auth_status_line("GitHub OAuth", File.exist?(GithubOAuth.default_auth_path), GithubOAuth.default_auth_path)
-        ProviderCatalog.api_key_providers.each do |provider|
-          lines << auth_status_line("#{provider.name} API key", store.configured?(provider.id), store.path)
+      def print_auth_status(show_all: false)
+        credentials = auth_credentials
+        configured, missing = credentials.partition { |credential| credential.fetch(:configured) }
+        lines = [colored("Authentication", :green, :bold), "", colored("Configured", :blue, :bold)]
+        lines.concat(auth_credential_lines(configured, status: :ok, empty_message: "None"))
+
+        if show_all
+          lines << ""
+          lines << colored("Not configured", :blue, :bold)
+          lines.concat(auth_credential_lines(missing, status: :optional, empty_message: "None"))
+        elsif missing.any?
+          lines << ""
+          lines << "#{missing.length} other provider#{missing.length == 1 ? " is" : "s are"} not configured. Run `kward auth status --all` for details."
         end
+
+        lines << ""
+        lines << colored("Credential directory", :blue, :bold)
+        lines << "  #{ConfigFiles.config_dir}"
         @prompt.say lines.join("\n")
       end
 
-      def auth_status_line(label, configured, location)
-        status = configured ? :ok : :warning
-        message = configured ? "configured" : "not configured"
-        "#{doctor_mark(status)} #{label}: #{message} (#{location})"
+      def auth_credentials
+        store = api_key_store
+        store.migrate_openrouter_config_key!
+        credentials = [
+          { label: "OpenAI OAuth", configured: File.exist?(OpenAIOAuth.default_auth_path) },
+          { label: "Anthropic OAuth", configured: File.exist?(AnthropicOAuth.default_auth_path) },
+          { label: "GitHub OAuth", configured: File.exist?(GithubOAuth.default_auth_path) }
+        ]
+        credentials.concat ProviderCatalog.api_key_providers.map { |provider| { label: "#{provider.name} API key", configured: store.configured?(provider.id) } }
+      end
+
+      def auth_credential_lines(credentials, status:, empty_message:)
+        return ["  #{empty_message}"] if credentials.empty?
+
+        credentials.map { |credential| "  #{doctor_mark(status)} #{credential.fetch(:label)}" }
       end
 
       def logout_auth

data/lib/kward/cli/commands.rb

@@ -38,67 +38,88 @@ module Kward
 
       # Writes the help output for the terminal CLI flow.
       def print_help
-        command = ->(text) { colored(text, :green, :bold) }
-        option = ->(text) { colored(text, :cyan) }
         heading = ->(text) { colored(text, :blue, :bold) }
+        lines = ["#{colored("Kward", :green, :bold)} - an extensible CLI coding agent", ""]
 
-        @prompt.say <<~HELP.rstrip
-          #{colored("Kward", :green, :bold)} - an extendable CLI coding agent
-
-          #{heading.call("Usage")}
-            #{command.call("kward")}                              Start an interactive chat
-            #{command.call("kward")} #{option.call('"Explain this project"')}       Run a one-shot prompt
-            #{command.call("kward --filter")} #{option.call('"Translate"')}          Filter stdin with an instruction
-            #{command.call("kward login")}                        Sign in or save provider credentials
-            #{command.call("kward auth status")}                  Show saved credential status
-            #{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
-            #{command.call("kward pan")}                          Start Pan mode web UI
-            #{command.call("kward rpc")}                          Start the JSON-RPC backend
-            #{command.call("kward transport")}                    Manage transport plugins
-
-          #{heading.call("Commands")}
-            #{command.call("help")}                               Show this help
-            #{command.call("version")}                            Show the installed Kward version
-            #{command.call("login")} [anthropic|openrouter|github] Sign in with OpenAI, Anthropic, OpenRouter, or GitHub
-            #{command.call("auth status|logout")}                 Show or clear saved credentials
-            #{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
-            #{command.call("openrouter refresh|list")}             Refresh or list cached OpenRouter models
-            #{command.call("pan")}                                Start Pan mode web UI
-            #{command.call("rpc")}                                Run the JSON-RPC backend for UI clients
-            #{command.call("transport list|status|run")}            Manage transport plugins
-
-          #{heading.call("Options")}
-            #{option.call("--working-directory=PATH")}             Run Kward from PATH
-            #{option.call("--mode=MODE")}                          Execution mode: auto, chat, oneshot, filter
-            #{option.call("--filter")}                              Shortcut for --mode filter
-            #{option.call("--skip-config")}                         Ignore the main config file for this run
-            #{option.call("--help")}, #{option.call("-h")}                         Show this help
-            #{option.call("--version")}, #{option.call("-v")}                      Show the installed version
-
-          #{heading.call("Examples")}
-            #{command.call("kward")}
-            #{command.call("kward")} #{option.call('"Explain this project"')}
-            #{command.call("git diff | kward")} #{option.call('"Summarize the main changes"')}
-            #{command.call("echo Hello | kward --filter")} #{option.call('"Translate to German"')}
-            #{command.call("kward login openrouter")}
-            #{command.call("kward edit lib/main.rb")}
-            #{command.call("kward openrouter refresh")}
-            #{command.call("kward stats tokens today --bucket hour")}
-
-          Command names take precedence. Anything else is sent as a one-shot prompt.
-        HELP
+        help_sections.each do |title, entries|
+          lines << heading.call(title)
+          lines.concat formatted_help_rows(entries, color: :green, bold: true)
+          lines << ""
+        end
+
+        lines << heading.call("Options")
+        lines.concat formatted_help_rows(help_options, color: :cyan)
+        lines << ""
+        lines << heading.call("Examples")
+        lines.concat help_examples.map { |example| "  #{colored(example, :green, :bold)}" }
+        lines << ""
+        lines << "Command names take precedence. Anything else is sent as a one-shot prompt."
+        @prompt.say lines.join("\n")
+      end
+
+      def help_sections
+        {
+          "Getting started" => [
+            ["kward", "Start an interactive chat"],
+            ["kward login [PROVIDER]", "Sign in or save provider credentials"],
+            ["kward doctor", "Check local Kward setup"],
+            ["kward init", "Install starter prompts and PRINCIPLES.md"]
+          ],
+          "Work" => [
+            ["kward \"PROMPT\"", "Run a one-shot prompt"],
+            ["kward --filter \"INSTRUCTION\"", "Filter standard input"],
+            ["kward edit <filename>", "Open a file in the integrated editor"],
+            ["kward sysprompt [--raw]", "Inspect the effective system prompt"]
+          ],
+          "Manage" => [
+            ["kward auth status [--all]", "Show saved credential status"],
+            ["kward hooks <command>", "Inspect lifecycle hooks"],
+            ["kward skills <command>", "Manage project skill trust"],
+            ["kward openrouter <command>", "Manage cached OpenRouter models"],
+            ["kward stats tokens [range] [options]", "Export local token telemetry as CSV"]
+          ],
+          "Integrate" => [
+            ["kward pan", "Start the local Pan web UI"],
+            ["kward rpc", "Start the JSON-RPC backend"],
+            ["kward transport <command>", "Manage transport plugins"]
+          ],
+          "Reference" => [
+            ["kward help [command]", "Show help"],
+            ["kward version", "Show the installed version"]
+          ]
+        }
+      end
+
+      def help_options
+        [
+          ["--working-directory=PATH", "Run Kward from PATH"],
+          ["--mode=MODE", "Execution mode: auto, chat, oneshot, filter"],
+          ["--filter", "Shortcut for --mode filter"],
+          ["--skip-config", "Ignore the main config file for this run"],
+          ["--help, -h", "Show help"],
+          ["--version, -v", "Show the installed version"]
+        ]
+      end
+
+      def help_examples
+        [
+          "kward",
+          "kward \"Explain this project\"",
+          "git diff | kward \"Summarize the main changes\"",
+          "echo Hello | kward --filter \"Translate to German\"",
+          "kward login openrouter",
+          "kward edit lib/main.rb",
+          "kward stats tokens today --bucket hour"
+        ]
+      end
+
+      def formatted_help_rows(entries, color:, bold: false)
+        width = entries.map { |label, _description| label.length }.max
+        styles = [color]
+        styles << :bold if bold
+        entries.map do |label, description|
+          "  #{colored(label.ljust(width), *styles)}  #{description}"
+        end
       end
 
       def command_help
@@ -119,9 +140,9 @@ module Kward
             examples: ["kward login", "kward login anthropic", "kward login openrouter", "kward login github"]
           },
           "auth" => {
-            usage: "kward auth status|logout",
+            usage: "kward auth status [--all]|logout",
             description: "Show or clear saved provider credentials without printing secrets.",
-            examples: ["kward auth status", "kward auth logout"]
+            examples: ["kward auth status", "kward auth status --all", "kward auth logout"]
           },
           "init" => {
             usage: "kward init",
@@ -165,7 +186,7 @@ module Kward
           },
           "pan" => {
             usage: "kward pan",
-            description: "Start Pan mode, a mobile-friendly LAN web UI with persistent sessions.",
+            description: "Start Pan mode, a mobile-friendly local web UI with persistent sessions.",
             examples: ["kward pan", "kward --working-directory ~/code/project pan"]
           },
           "rpc" => {

data/lib/kward/cli/doctor.rb

@@ -8,11 +8,32 @@ module Kward
 
       # Writes the doctor output for the terminal CLI flow.
       def print_doctor
-        lines = ["#{colored("Kward Doctor", :green, :bold)}", ""]
-        doctor_checks.each do |check|
-          lines << "#{doctor_mark(check.fetch(:status))} #{check.fetch(:label)}: #{check.fetch(:message)}"
+        checks = doctor_checks
+        core_checks, optional_checks = checks.partition { |check| !check[:optional] }
+        lines = [colored("Kward Doctor", :green, :bold), "", colored("Core checks", :blue, :bold)]
+        lines.concat(doctor_check_lines(core_checks))
+        if optional_checks.any?
+          lines << ""
+          lines << colored("Optional", :blue, :bold)
+          lines.concat(doctor_check_lines(optional_checks))
         end
+        lines << ""
+        lines << doctor_summary(checks)
         @prompt.say lines.join("\n")
+        checks.none? { |check| check.fetch(:status) == :error && !check[:optional] }
+      end
+
+      def doctor_check_lines(checks)
+        checks.map { |check| "#{doctor_mark(check.fetch(:status))} #{check.fetch(:label)}: #{check.fetch(:message)}" }
+      end
+
+      def doctor_summary(checks)
+        errors = checks.count { |check| check.fetch(:status) == :error && !check[:optional] }
+        warnings = checks.count { |check| check.fetch(:status) == :warning && !check[:optional] }
+        return "Kward needs attention: #{errors} core check#{errors == 1 ? "" : "s"} failed." if errors.positive?
+        return "Kward is ready with #{warnings} warning#{warnings == 1 ? "" : "s"}." if warnings.positive?
+
+        "Kward is ready."
       end
 
       def doctor_checks
@@ -108,29 +129,28 @@ module Kward
         { status: :error, label: "Local endpoint", message: "invalid URL: #{url}" }
       end
 
-      def doctor_auth_check(config)
-        openai_auth = OpenAIOAuth.default_auth_path
-        github_auth = GithubOAuth.default_auth_path
-        has_openrouter = !config.to_h["openrouter_api_key"].to_s.empty? || !ENV["OPENROUTER_API_KEY"].to_s.empty?
+      def doctor_auth_check(_config)
         local_provider = @client.respond_to?(:current_provider) && @client.current_provider == "Local"
-        paths = []
-        paths << "OpenAI OAuth" if File.exist?(openai_auth)
-        paths << "GitHub OAuth" if File.exist?(github_auth)
-        paths << "OpenRouter API key" if has_openrouter
-        paths << "Local endpoint (no authentication required)" if local_provider
-        return { status: :ok, label: "Auth", message: paths.join(", ") } if paths.any?
+        configured = auth_credentials.select { |credential| credential.fetch(:configured) }.map { |credential| credential.fetch(:label) }
+        configured << "Local endpoint (no authentication required)" if local_provider
+        return { status: :ok, label: "Auth", message: configured.join(", ") } if configured.any?
 
         { status: :warning, label: "Auth", message: "no saved credentials found; run `kward login`" }
+      rescue ConfigFiles::ConfigError
+        { status: :warning, label: "Auth", message: "skipped because config is invalid" }
       end
 
       def doctor_pan_check(config_result)
-        return { status: :warning, label: "Pan mode", message: "skipped because config is invalid" } if config_result.is_a?(ConfigFiles::ConfigError)
+        return { status: :optional, label: "Pan mode", message: "skipped because config is invalid", optional: true } if config_result.is_a?(ConfigFiles::ConfigError)
 
         pan = config_result.to_h["pan_mode"] || {}
-        if !pan["username"].to_s.empty? && !pan["password"].to_s.empty?
-          { status: :ok, label: "Pan mode", message: "credentials configured" }
+        environment_password = ENV["KWARD_PAN_PASSWORD"].to_s
+        password = environment_password.empty? ? pan["password"].to_s : environment_password
+        if !pan["username"].to_s.empty? && !password.empty?
+          source = environment_password.empty? ? "config" : "environment"
+          { status: :ok, label: "Pan mode", message: "credentials configured (password from #{source})", optional: true }
         else
-          { status: :warning, label: "Pan mode", message: "username/password not configured" }
+          { status: :optional, label: "Pan mode", message: "not configured", optional: true }
         end
       end
 
@@ -140,6 +160,8 @@ module Kward
           colored("✓", :green, :bold)
         when :warning
           colored("!", :yellow, :bold)
+        when :optional
+          colored("•", :gray, :bold)
         else
           colored("✗", :red, :bold)
         end

data/lib/kward/cli/hook_commands.rb

@@ -9,7 +9,9 @@ module Kward
     module HookCommands
       private
 
-      def handle_hooks_command(argument)
+      def handle_hooks_command(argument, command_line: false)
+        previous_output_mode = @hook_command_line_output
+        @hook_command_line_output = command_line
         subcommand, rest = argument.to_s.strip.split(/\s+/, 2)
         subcommand = "list" if subcommand.to_s.empty?
 
@@ -27,8 +29,16 @@ module Kward
         when "untrust"
           untrust_workspace_hooks
         else
-          runtime_output("Usage: /hooks [list|events|logs|doctor|trust|untrust]")
+          raise ArgumentError, command_usage("hooks") if command_line
+
+          hook_command_output("Usage: /hooks [list|events|logs|doctor|trust|untrust]")
         end
+      ensure
+        @hook_command_line_output = previous_output_mode
+      end
+
+      def hook_command_output(text)
+        @hook_command_line_output ? @prompt.say(text) : runtime_output(text)
       end
 
       def print_hooks_list
@@ -46,7 +56,7 @@ module Kward
             lines << "- #{details.join(' ')}"
           end
         end
-        runtime_output(lines.join("\n"))
+        hook_command_output(lines.join("\n"))
       end
 
       def print_hooks_events
@@ -57,7 +67,7 @@ module Kward
           suffix = fields.empty? ? "" : " modifies=#{fields.join(',')}"
           lines << "- #{event_name} failure_policy=#{Hooks::Catalog.failure_policy(event_name)}#{suffix}"
         end
-        runtime_output(lines.join("\n"))
+        hook_command_output(lines.join("\n"))
       end
 
       def print_hooks_logs(argument)
@@ -65,7 +75,7 @@ module Kward
         count = 20 unless count.positive?
         path = hooks_log_path
         unless File.file?(path)
-          runtime_output("No lifecycle hook audit log found at #{path}.")
+          hook_command_output("No lifecycle hook audit log found at #{path}.")
           return
         end
 
@@ -75,7 +85,7 @@ module Kward
           nil
         end
         if records.empty?
-          runtime_output("No readable lifecycle hook audit records found at #{path}.")
+          hook_command_output("No readable lifecycle hook audit records found at #{path}.")
           return
         end
 
@@ -83,7 +93,7 @@ module Kward
         records.each do |record|
           lines << format_hook_log_record(record)
         end
-        runtime_output(lines.join("\n"))
+        hook_command_output(lines.join("\n"))
       end
 
       def print_hooks_doctor
@@ -105,7 +115,7 @@ module Kward
         rescue StandardError => e
           lines << "Error: #{e.message}"
         end
-        runtime_output(lines.join("\n"))
+        hook_command_output(lines.join("\n"))
       end
 
       def configured_hook_entries
@@ -226,16 +236,16 @@ module Kward
 
       def trust_workspace_hooks
         ConfigFiles.trust_workspace_hooks!(current_workspace_root)
-        runtime_output("Trusted workspace hooks: #{ConfigFiles.workspace_hooks_path(current_workspace_root)}")
+        hook_command_output("Trusted workspace hooks: #{ConfigFiles.workspace_hooks_path(current_workspace_root)}")
       rescue StandardError => e
-        runtime_output("Workspace hook trust error: #{e.message}")
+        hook_command_output("Workspace hook trust error: #{e.message}")
       end
 
       def untrust_workspace_hooks
         ConfigFiles.untrust_workspace_hooks!(current_workspace_root)
-        runtime_output("Untrusted workspace hooks: #{ConfigFiles.workspace_hooks_path(current_workspace_root)}")
+        hook_command_output("Untrusted workspace hooks: #{ConfigFiles.workspace_hooks_path(current_workspace_root)}")
       rescue StandardError => e
-        runtime_output("Workspace hook trust error: #{e.message}")
+        hook_command_output("Workspace hook trust error: #{e.message}")
       end
 
       def hooks_log_path