kward 0.77.0 → 0.79.0

data/lib/kward/auth/anthropic_oauth.rb

@@ -202,8 +202,8 @@ module Kward
       parse_successful_json(response, "Anthropic OAuth token exchange")
     end
 
-    def post_json(uri, params)
-      super(uri, params, headers: { "Accept" => "application/json" })
+    def post_json(uri, params = nil, **keyword_params)
+      super(uri, params, headers: { "Accept" => "application/json" }, **keyword_params)
     end
   end
 end

data/lib/kward/auth/github_oauth.rb

@@ -4,6 +4,7 @@ require "time"
 require "uri"
 require_relative "file"
 require_relative "../config_files"
+require_relative "../http"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -15,7 +16,6 @@ module Kward
     DEFAULT_SCOPE = "read:user"
     DEFAULT_CLIENT_ID = "Iv1.b507a08c87ecfe98"
     COPILOT_HEADERS = {
-      "User-Agent" => "GitHubCopilotChat/0.35.0",
       "Editor-Version" => "vscode/1.107.0",
       "Editor-Plugin-Version" => "copilot-chat/0.35.0",
       "Copilot-Integration-Id" => "vscode-chat"
@@ -150,7 +150,7 @@ module Kward
     end
 
     def post_form(uri, params)
-      request = Net::HTTP::Post.new(uri)
+      request = Http.apply_user_agent(Net::HTTP::Post.new(uri))
       request["Content-Type"] = "application/x-www-form-urlencoded"
       request["Accept"] = "application/json"
       request.body = URI.encode_www_form(params)
@@ -160,7 +160,7 @@ module Kward
     end
 
     def get_json(uri, headers = {})
-      request = Net::HTTP::Get.new(uri)
+      request = Http.apply_user_agent(Net::HTTP::Get.new(uri))
       request["Accept"] = "application/json"
       COPILOT_HEADERS.merge(headers).each { |key, value| request[key] = value }
 

data/lib/kward/auth/oauth_helpers.rb

@@ -6,6 +6,7 @@ require "securerandom"
 require "socket"
 require "time"
 require "uri"
+require_relative "../http"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -58,8 +59,9 @@ module Kward
       socket&.close
     end
 
-    def post_json(uri, params, headers: {})
-      request = Net::HTTP::Post.new(uri)
+    def post_json(uri, params = nil, headers: {}, **keyword_params)
+      params = (params || {}).merge(keyword_params)
+      request = Http.apply_user_agent(Net::HTTP::Post.new(uri))
       request["Content-Type"] = "application/json"
       headers.each { |key, value| request[key] = value }
       request.body = JSON.dump(params)

data/lib/kward/auth/openai_oauth.rb

@@ -5,6 +5,7 @@ require "time"
 require "uri"
 require_relative "file"
 require_relative "oauth_helpers"
+require_relative "../http"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -215,7 +216,7 @@ module Kward
     end
 
     def post_form(uri, params)
-      request = Net::HTTP::Post.new(uri)
+      request = Http.apply_user_agent(Net::HTTP::Post.new(uri))
       request["Content-Type"] = "application/x-www-form-urlencoded"
       request.body = URI.encode_www_form(params)
 

data/lib/kward/cli/doctor.rb

@@ -25,6 +25,7 @@ module Kward
           doctor_directory_check("Session directory", SessionStore.new(cwd: current_workspace_root).session_dir, create: true),
           doctor_workspace_check,
           doctor_model_check,
+          doctor_local_endpoint_check(config),
           doctor_auth_check(config),
           doctor_pan_check(config_result),
           { status: :ok, label: "Color", message: @color_enabled ? "enabled" : "disabled" }
@@ -89,14 +90,34 @@ module Kward
         { status: :warning, label: "Model", message: e.message }
       end
 
+      def doctor_local_endpoint_check(config)
+        provider = ENV["KWARD_PROVIDER"].to_s.strip
+        provider = config["provider"].to_s.strip if provider.empty?
+        return { status: :ok, label: "Local endpoint", message: "not selected" } unless provider.casecmp?("local")
+
+        backend = ENV["KWARD_LOCAL_BACKEND"].to_s.strip
+        backend = config["local_backend"].to_s.strip if backend.empty?
+        defaults = Kward::Client::LOCAL_BASE_URLS
+        url = ENV["KWARD_LOCAL_BASE_URL"].to_s.strip
+        url = config["local_base_url"].to_s.strip if url.empty?
+        url = defaults.fetch(backend.empty? ? "ollama" : backend, defaults.fetch("ollama")) if url.empty?
+        uri = URI.parse(url)
+        loopback = ["127.0.0.1", "::1", "localhost"].include?(uri.host)
+        { status: loopback ? :ok : :warning, label: "Local endpoint", message: "#{url}#{loopback ? " (loopback)" : " (non-loopback)"}" }
+      rescue URI::InvalidURIError
+        { 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?
+        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?
 
         { status: :warning, label: "Auth", message: "no saved credentials found; run `kward login`" }

data/lib/kward/cli/plugins.rb

@@ -102,6 +102,17 @@ module Kward
         end
       end
 
+      def update_plugin_tab_slash_commands(tab)
+        return unless @prompt.respond_to?(:update_slash_commands)
+
+        entries = if tab&.driver&.respond_to?(:slash_command_entries)
+          tab.driver.slash_command_entries
+        else
+          []
+        end
+        @prompt.update_slash_commands(slash_command_entries + Array(entries))
+      end
+
       def slash_command_entries
         prompt_entries = prompt_templates.map do |template|
           {
@@ -192,6 +203,17 @@ module Kward
         plugin_registry.notify_transcript_event(event, plugin_context(conversation, ""))
       end
 
+      def notify_plugin_tab_transcript_event(event, driver)
+        return if plugin_registry.transcript_event_handlers.empty?
+
+        context = PluginRegistry::Context.new(
+          conversation: driver,
+          workspace_root: current_workspace_root,
+          say_callback: lambda { |message| runtime_output(message) }
+        )
+        plugin_registry.notify_transcript_event(event, context)
+      end
+
     end
   end
 end

data/lib/kward/cli/rendering.rb

@@ -7,9 +7,15 @@ module Kward
       private
 
       def render_conversation_transcript(conversation)
+        render_transcript_messages(conversation.messages)
+      end
+
+      # Renders a transcript supplied by either a Kward conversation or a
+      # plugin-owned tab driver.
+      def render_transcript_messages(messages)
         tool_calls_by_id = {}
         @prompt.say("\n#{colored("Transcript", :gray, :bold)}\n")
-        conversation.messages.each do |message|
+        Array(messages).each do |message|
           role = message_role(message)
           next if role == "system"
 

data/lib/kward/cli/runtime_helpers.rb

@@ -50,6 +50,7 @@ module Kward
         tool_registry = ToolRegistry.new(
           workspace: workspace,
           prompt: @prompt,
+          tool_approval: interactive_tool_approval_callback,
           hook_manager: hook_manager,
           hook_context: hook_context
         )
@@ -64,6 +65,19 @@ module Kward
         )
       end
 
+      def interactive_tool_approval_callback
+        return nil unless @prompt.respond_to?(:ask_tool_approval)
+        return nil unless ConfigFiles.permission_policy(safely_read_config.to_h).enabled?
+
+        lambda do |tool_call:, name:, args:, cancellation:|
+          @prompt.ask_tool_approval(
+            tool_name: name,
+            args: args,
+            reason: args["hook_message"] || args[:hook_message]
+          )
+        end
+      end
+
       def handle_interactive_shell_command(input, agent)
         command = input.to_s.sub(/\A!\s*/, "")
         if command.strip.empty?
@@ -304,7 +318,7 @@ module Kward
       end
 
       def configured_workspace(root: current_workspace_root)
-        Workspace.new(root: root, guardrails: workspace_guardrails_enabled?)
+        WorkspaceFactory.build(root: root, guardrails: workspace_guardrails_enabled?, config: safely_read_config.to_h)
       end
 
       def workspace_guardrails_enabled?

data/lib/kward/cli/settings.rb

@@ -88,7 +88,7 @@ module Kward
       def configure_model_settings(conversation)
         initial_index = 0
         loop do
-          selected, selected_index = select_settings_menu_item("Model & Reasoning", ["Provider", "Default model", "Reasoning effort", "Back"], initial_index)
+          selected, selected_index = select_settings_menu_item("Model & Reasoning", ["Provider", "Default model", "Local server preset", "Reasoning effort", "Back"], initial_index)
           break unless selected
 
           initial_index = selected_index if selected_index
@@ -97,6 +97,8 @@ module Kward
             configure_provider(conversation)
           when /\Adefault model/
             configure_model(conversation)
+          when /\Alocal server preset/
+            configure_local_server_preset(conversation)
           when /\Areasoning effort/
             configure_reasoning(conversation)
           else
@@ -118,7 +120,7 @@ module Kward
 
       def provider_choices
         current = current_model_provider
-        ["Codex", "Anthropic", "OpenRouter", "Copilot"].map do |provider|
+        ["Codex", "Anthropic", "OpenRouter", "Copilot", "Local"].map do |provider|
           label = provider.dup
           label += " (current)" if provider == current
           label
@@ -131,10 +133,39 @@ module Kward
         return "Anthropic" if text.start_with?("anthropic") || text.start_with?("claude")
         return "OpenRouter" if text.start_with?("openrouter")
         return "Copilot" if text.start_with?("copilot")
+        return "Local" if text.start_with?("local")
 
         nil
       end
 
+      def configure_local_server_preset(conversation)
+        choices = [
+          "Ollama (http://127.0.0.1:11434/v1)",
+          "LM Studio (http://127.0.0.1:1234/v1)",
+          "llama.cpp (http://127.0.0.1:8080/v1)",
+          "Custom endpoint (edit config)",
+          "Back"
+        ]
+        selected = @prompt.select("Local server preset", choices, title: "Settings")
+        return unless selected
+
+        backend, url = case selected.to_s
+                       when /\AOllama/ then ["ollama", "http://127.0.0.1:11434/v1"]
+                       when /\ALM Studio/ then ["lm_studio", "http://127.0.0.1:1234/v1"]
+                       when /\Allama\.cpp/ then ["llama_cpp", "http://127.0.0.1:8080/v1"]
+                       when /\ACustom endpoint/
+                         runtime_output("Set local_base_url in #{ConfigFiles.config_path}.")
+                         return
+                       else
+                         return
+                       end
+
+        ConfigFiles.update_config("local_backend" => backend, "local_base_url" => url)
+        reload_client_config
+        refresh_conversation_runtime(conversation)
+        @prompt.redraw if @prompt.respond_to?(:redraw)
+      end
+
       def configure_account_settings
         initial_index = 0
         loop do
@@ -524,6 +555,10 @@ module Kward
           case selected.to_s.downcase
           when /\Adefault persona/
             configure_default_persona(conversation)
+          when /\Aenable global principles/, /\Adisable global principles/
+            toggle_global_principles(conversation)
+          when /\Aglobal principles \(ignored/
+            runtime_output("Global principles are ignored while a replacement system prompt is configured.")
           when /\Aactive instructions/
             show_active_instructions_summary(conversation)
           else
@@ -533,13 +568,31 @@ module Kward
       end
 
       def personalization_setting_choices(conversation)
+        config = safely_read_config.to_h
+        replacement = ConfigFiles.system_prompt_file_path(config)
+        principles = if replacement
+                       "Global principles (ignored by replacement)"
+                     elsif ConfigFiles.include_config_principles?(config)
+                       "Disable global principles"
+                     else
+                       "Enable global principles"
+                     end
         [
           "Default persona (#{default_persona_label})",
+          principles,
           "Active instructions summary",
           "Back"
         ]
       end
 
+      def toggle_global_principles(conversation)
+        config = safely_read_config.to_h
+        settings = config["system_prompt"].is_a?(Hash) ? config["system_prompt"] : {}
+        ConfigFiles.update_config("system_prompt" => settings.merge("include_principles" => !ConfigFiles.include_config_principles?(config)))
+        conversation&.refresh_system_message!
+        @prompt.redraw if @prompt.respond_to?(:redraw)
+      end
+
       def default_persona_label
         personas = safely_read_config.to_h["personas"]
         value = personas.is_a?(Hash) ? personas["default"] : nil
@@ -569,9 +622,18 @@ module Kward
 
       def show_active_instructions_summary(conversation)
         label = ConfigFiles.active_persona_label(workspace_root: current_workspace_root, model: current_model_id, config: safely_read_config.to_h)
+        config = safely_read_config.to_h
+        replacement_path = ConfigFiles.system_prompt_file_path(config)
         lines = ["Active persona: #{label || "none"}"]
-        lines << "Global PRINCIPLES.md: #{ConfigFiles.agents_prompt ? "present" : "absent"}"
-        lines << "Workspace AGENTS.md: #{ConfigFiles.workspace_agents_prompt(current_workspace_root) ? "present" : "absent"}"
+        if replacement_path
+          lines << "System prompt: replacement (#{replacement_path})"
+          lines << "Global PRINCIPLES.md: ignored by replacement"
+          lines << "Workspace AGENTS.md: ignored by replacement"
+        else
+          lines << "System prompt: Kward default"
+          lines << "Global PRINCIPLES.md: #{ConfigFiles.include_config_principles?(config) ? (ConfigFiles.agents_prompt ? "present" : "absent") : "disabled"}"
+          lines << "Workspace AGENTS.md: #{ConfigFiles.workspace_agents_prompt(current_workspace_root) ? "present" : "absent"}"
+        end
         lines << "Messages: #{conversation.messages.length}" if conversation&.respond_to?(:messages)
         runtime_output(lines.join("\n"))
       end

data/lib/kward/cli/slash_commands.rb

@@ -15,6 +15,9 @@ module Kward
         when "stats"
           run_busy_local_command_and_requeue { print_stats(argument) }
           [true, nil]
+        when "sandbox"
+          run_busy_local_command_and_requeue { handle_sandbox_command(argument, interactive_workspace_root(agent)) }
+          [true, nil]
         when "memory"
           activity = memory_summarize_command?(argument) ? "summarizing" : "loading"
           run_busy_local_command_and_requeue(activity: activity) { handle_memory_command(argument, agent) }
@@ -23,7 +26,11 @@ module Kward
           run_busy_local_command_and_requeue { handle_hooks_command(argument) }
           [true, nil]
         when "skill"
-          run_busy_local_command_and_requeue { activate_skill_command(argument, agent) }
+          if argument.to_s.strip == "capture"
+            capture_skill_from_session(session_store)
+          else
+            run_busy_local_command_and_requeue { activate_skill_command(argument, agent) }
+          end
           [true, nil]
         when "redraw"
           run_busy_local_command_and_requeue { @prompt.redraw if @prompt.respond_to?(:redraw) }
@@ -114,6 +121,48 @@ module Kward
         PromptCommands.parse(command) || [nil, ""]
       end
 
+      def handle_sandbox_command(argument, workspace_root)
+        action, value = argument.to_s.strip.split(/\s+/, 2)
+        case action
+        when nil, "", "status"
+          print_sandbox_status(workspace_root)
+        when *Sandbox::Policy::MODES
+          ConfigFiles.update_nested_config("sandbox", { "mode" => action })
+          runtime_output("Command sandbox mode set to #{action}. New sessions and tabs use the updated policy.")
+        when "network"
+          network = value.to_s
+          unless Sandbox::Policy::NETWORK_MODES.include?(network)
+            runtime_output("Usage: /sandbox network allow|deny")
+            return
+          end
+
+          ConfigFiles.update_nested_config("sandbox", { "network" => network })
+          runtime_output("Command sandbox child network set to #{network}. New sessions and tabs use the updated policy.")
+        else
+          runtime_output("Usage: /sandbox [status|off|read_only|workspace_write|network allow|network deny]")
+        end
+      rescue ArgumentError => error
+        runtime_output("Sandbox configuration error: #{error.message}")
+      end
+
+      def print_sandbox_status(workspace_root)
+        config = ConfigFiles.read_config
+        policy = ConfigFiles.sandbox_policy(workspace_root, config)
+        runner = Sandbox::RunnerFactory.build(policy)
+        capabilities = runner.capabilities
+        lines = [
+          "Command sandbox",
+          "Mode: #{policy.mode}",
+          "Child network: #{policy.network}",
+          "Backend: #{capabilities.backend}",
+          "Filesystem enforcement: #{capabilities.filesystem_enforced? ? "active" : "inactive"}",
+          "Child-network enforcement: #{capabilities.child_network_enforced? ? "active" : "inactive"}",
+          "Scope: model-requested run_shell_command workers only"
+        ]
+        lines << "Reason: #{capabilities.reason}" unless capabilities.reason.to_s.empty?
+        runtime_output(lines.join("\n"))
+      end
+
       def open_or_resume_session(session_store, argument)
         unless session_store
           say_sessions_unavailable
@@ -144,6 +193,65 @@ module Kward
         end
       end
 
+      def capture_skill_from_session(session_store)
+        unless session_store
+          say_sessions_unavailable
+          return
+        end
+        unless @prompt.respond_to?(:review_document)
+          runtime_output("Skill capture is available only in the interactive terminal prompt.")
+          return
+        end
+
+        source_path = select_skill_capture_session(session_store)
+        return unless source_path
+
+        capture = Skills::Capture.new(session_store: session_store, client: @client)
+        draft = run_busy_local_command_and_requeue(activity: "capturing skill") { capture.generate(source_path) }
+        review_captured_skill(capture, draft)
+      rescue Skills::Capture::Error => error
+        runtime_output("Skill capture failed: #{error.message}")
+      end
+
+      def select_skill_capture_session(session_store)
+        sessions = session_store.capture_candidates
+        if sessions.empty?
+          runtime_output("No saved sessions found.")
+          return nil
+        end
+
+        labels = session_picker_labels(sessions)
+        if @prompt.respond_to?(:select)
+          choice = @prompt.select("Capture session>", labels, title: "Capture skill from session")
+          return sessions[labels.index(choice)]&.path
+        end
+
+        runtime_output((["Saved sessions:"] + labels.each_with_index.map { |label, index| "#{index + 1}. #{label}" }).join("\n"))
+        answer = @prompt.ask("Session number or path>").to_s.strip
+        answer.match?(/\A\d+\z/) ? sessions[answer.to_i - 1]&.path : answer
+      end
+
+      def review_captured_skill(capture, draft)
+        overwrite = false
+        saved = nil
+        @prompt.review_document(title: "Review captured skill", content: draft.content) do |content|
+          begin
+            saved = capture.save(content, overwrite: overwrite)
+            nil
+          rescue Skills::Capture::ConflictError
+            if overwrite
+              "Could not overwrite the existing skill. Review the name and try again."
+            else
+              overwrite = true
+              "A personal skill with this name exists. Press Ctrl+S again to overwrite it."
+            end
+          rescue Skills::Capture::Error => error
+            error.message
+          end
+        end
+        runtime_output("Saved personal skill: #{capture.skill_path(saved.name)}") if saved
+      end
+
       def activate_skill_command(name, agent)
         skill_name = name.to_s.strip
         if skill_name.empty?