kward 0.78.0 → 0.79.0

data/lib/kward/model/client.rb

@@ -29,6 +29,11 @@ module Kward
     OPENROUTER_URL = URI("https://openrouter.ai/api/v1/chat/completions")
     CODEX_URL = URI("https://chatgpt.com/backend-api/codex/responses")
     ANTHROPIC_URL = URI("https://api.anthropic.com/v1/messages")
+    LOCAL_BASE_URLS = {
+      "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"
+    }.freeze
     AUTH_ERROR = "No OpenAI OAuth login found. Run `ruby lib/main.rb login`, or set OPENAI_ACCESS_TOKEN/OPENROUTER_API_KEY."
     OPENROUTER_AUTH_ERROR = "No OpenRouter API key found. Set OPENROUTER_API_KEY or add openrouter_api_key to your Kward config."
     COPILOT_AUTH_ERROR = "No GitHub Copilot OAuth login found. Run `ruby lib/main.rb login github` or set COPILOT_GITHUB_TOKEN."
@@ -94,18 +99,19 @@ module Kward
       @telemetry_logger = telemetry_logger
       @copilot_models = nil
       @openrouter_models = nil
+      @local_models = nil
     end
 
     def chat(messages, tools: [], on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, on_retry: nil, cancellation: nil, steering: nil, max_tokens: nil, provider: nil, model: nil, reasoning: nil)
       cancellation&.raise_if_cancelled!
       requested_provider = provider
       url, token, resolved_provider, account_id = credentials(provider: requested_provider)
-      if token.to_s.empty? && !requested_provider.to_s.empty?
+      if token.to_s.empty? && authentication_required?(resolved_provider) && !requested_provider.to_s.empty?
         url, token, resolved_provider, account_id = credentials
         model = nil
         reasoning = nil
       end
-      raise auth_error_for(resolved_provider) if token.nil? || token.empty?
+      raise auth_error_for(resolved_provider) if authentication_required?(resolved_provider) && (token.nil? || token.empty?)
 
       current_model = model_for(resolved_provider, override_model: model)
       current_model = resolved_copilot_chat_model(current_model) if resolved_provider == "Copilot" && model.nil?
@@ -180,7 +186,10 @@ module Kward
 
     # Returns the known context window for a provider/model pair.
     def context_window(provider, model)
-      context_window_for(ModelInfo.provider_label(provider), model)
+      provider = ModelInfo.provider_label(provider)
+      return local_context_window if provider == "Local"
+
+      context_window_for(provider, model)
     end
 
     # Returns model choices suitable for settings UIs.
@@ -226,6 +235,14 @@ module Kward
         models << model_entry("Anthropic", anthropic_model, current: provider == "Anthropic") unless ModelInfo::ANTHROPIC_MODEL_CHOICES.include?(anthropic_model)
       end
 
+      if provider_logged_in?("Local")
+        local_model = model_for("Local")
+        local_model_choices.each do |id|
+          models << model_entry("Local", id, current: provider == "Local" && local_model == id)
+        end
+        models << model_entry("Local", local_model, current: provider == "Local") unless local_model.to_s.empty? || local_model_choices.include?(local_model)
+      end
+
       # Sort models by provider, then alphabetically by id
       models.sort_by { |model| [model[:provider], model[:id]] }
     end
@@ -247,6 +264,7 @@ module Kward
       @config = load_config
       @copilot_models = nil
       @openrouter_models = nil
+      @local_models = nil
     end
 
     private
@@ -298,6 +316,15 @@ module Kward
           on_assistant_delta: on_assistant_delta,
           cancellation: cancellation
         )
+      when "Local"
+        chat_local_provider(
+          url: url,
+          token: token,
+          request_body: request_body,
+          current_model: current_model,
+          on_assistant_delta: on_assistant_delta,
+          cancellation: cancellation
+        )
       else
         chat_openrouter_provider(
           url: url,
@@ -362,6 +389,31 @@ module Kward
       attach_response_metadata(message, provider: "Anthropic", model: current_model)
     end
 
+    def chat_local_provider(url:, token:, request_body:, current_model:, on_assistant_delta:, cancellation:)
+      request = Http.apply_user_agent(Net::HTTP::Post.new(url))
+      request["Authorization"] = "Bearer #{token}" unless token.to_s.empty?
+      request["Content-Type"] = "application/json"
+      request["Accept"] = "text/event-stream"
+      request.body = request_body
+
+      message = nil
+      Net::HTTP.start(url.hostname, url.port, use_ssl: url.scheme == "https", read_timeout: stream_idle_timeout_seconds) do |http|
+        cancellation&.on_cancel { close_http(http) }
+        cancellation&.raise_if_cancelled!
+        http.request(request) do |response|
+          unless response.is_a?(Net::HTTPSuccess)
+            body = +""
+            response.read_body { |chunk| body << chunk }
+            raise RequestError.new(provider: "Local", code: response.code, body: redact(body, token))
+          end
+
+          message = parse_openai_chat_sse_stream(response, on_assistant_delta: on_assistant_delta, cancellation: cancellation, provider_label: "Local")
+        end
+      end
+      cancellation&.raise_if_cancelled!
+      attach_response_metadata(message, provider: "Local", model: current_model)
+    end
+
     def chat_openrouter_provider(url:, token:, request_body:, current_model:, on_assistant_delta:, cancellation:)
       request = Http.apply_user_agent(Net::HTTP::Post.new(url))
       request["Authorization"] = "Bearer #{token}"
@@ -504,9 +556,30 @@ module Kward
     end
 
     def context_window_for(provider, id)
+      return local_context_window if provider == "Local"
+
       ModelInfo.context_window(provider, id, openrouter_models: openrouter_cached_model_entries)
     end
 
+    def local_model_choices
+      return @local_models if @local_models
+
+      url = local_models_url
+      request = Http.apply_user_agent(Net::HTTP::Get.new(url))
+      request["Authorization"] = "Bearer #{local_api_key}" unless local_api_key.to_s.empty?
+      request["Accept"] = "application/json"
+      response = Net::HTTP.start(url.hostname, url.port, use_ssl: url.scheme == "https", read_timeout: stream_idle_timeout_seconds) { |http| http.request(request) }
+      return @local_models = [] unless response.is_a?(Net::HTTPSuccess)
+
+      body = JSON.parse(response.body)
+      entries = body["data"] || body["models"] || []
+      @local_models = Array(entries).filter_map do |entry|
+        entry.is_a?(Hash) ? entry["id"] || entry[:id] || entry["model"] || entry[:model] : entry
+      end.map(&:to_s).map(&:strip).reject(&:empty?).uniq
+    rescue StandardError
+      @local_models = []
+    end
+
     def openrouter_model_choices
       openrouter_cached_models.uniq
     end
@@ -627,7 +700,11 @@ module Kward
     end
 
     def parse_openai_chat_sse(body, on_assistant_delta: nil)
-      ModelStreamParser.parse_openai_chat_sse(body, on_assistant_delta: on_assistant_delta, usage_normalizer: method(:normalized_usage))
+      ModelStreamParser.parse_openai_chat_sse(body, on_assistant_delta: on_assistant_delta, usage_normalizer: method(:normalized_usage), provider_label: "Copilot")
+    end
+
+    def parse_openai_chat_sse_stream(response, on_assistant_delta: nil, cancellation: nil, provider_label: "OpenAI-compatible provider")
+      ModelStreamParser.parse_openai_chat_sse_stream(response, on_assistant_delta: on_assistant_delta, cancellation: cancellation, usage_normalizer: method(:normalized_usage), provider_label: provider_label)
     end
 
     def anthropic_headers
@@ -776,6 +853,10 @@ module Kward
 
     def credentials(provider: nil)
       provider = provider.to_s.empty? ? ModelInfo.provider_label(configured_provider) : ModelInfo.provider_label(provider)
+      if provider == "Local"
+        return [local_chat_url, local_api_key, provider, nil]
+      end
+
       if provider == "Copilot"
         return [copilot_chat_url, github_access_token, provider, nil]
       end
@@ -806,8 +887,14 @@ module Kward
       ModelInfo.reasoning_effort(config: @config, provider: provider)
     end
 
+    def authentication_required?(provider)
+      provider != "Local"
+    end
+
     def provider_logged_in?(provider)
       case provider
+      when "Local"
+        local_configured?
       when "Codex"
         openai_configured?
       when "OpenRouter"
@@ -829,6 +916,53 @@ module Kward
       false
     end
 
+    def local_configured?
+      configured_provider == "local" || !local_model.to_s.empty? || !config_value("local_base_url").to_s.empty? || !ENV["KWARD_LOCAL_BASE_URL"].to_s.empty?
+    end
+
+    def local_model
+      ENV["KWARD_LOCAL_MODEL"] || config_value("local_model")
+    end
+
+    def local_context_window
+      value = ENV["KWARD_LOCAL_CONTEXT_WINDOW"] || config_value("local_context_window")
+      positive_integer(value)
+    end
+
+    def local_api_key
+      ENV["KWARD_LOCAL_API_KEY"] || config_value("local_api_key")
+    end
+
+    def local_backend
+      presence(ENV["KWARD_LOCAL_BACKEND"].to_s.strip) || presence(config_value("local_backend").to_s.strip) || "ollama"
+    end
+
+    def local_base_url
+      configured = presence(ENV["KWARD_LOCAL_BASE_URL"].to_s.strip) || presence(config_value("local_base_url").to_s.strip)
+      return configured if configured
+
+      LOCAL_BASE_URLS.fetch(local_backend) { raise "Unknown local model backend: #{local_backend}" }
+    end
+
+    def local_chat_url
+      local_url("chat/completions")
+    end
+
+    def local_models_url
+      local_url("models")
+    end
+
+    def local_url(path)
+      base = URI.parse(local_base_url)
+      unless base.is_a?(URI::HTTP) && base.host && !base.host.empty? && base.user.nil? && base.password.nil? && base.query.nil? && base.fragment.nil?
+        raise "Invalid local model URL: #{local_base_url}"
+      end
+
+      URI("#{base.to_s.sub(%r{/+\z}, "")}/#{path}")
+    rescue URI::InvalidURIError
+      raise "Invalid local model URL: #{local_base_url}"
+    end
+
     def openrouter_api_key
       @openrouter_api_key || config_value("openrouter_api_key")
     end
@@ -869,6 +1003,8 @@ module Kward
     end
 
     def redact(text, token)
+      return text.to_s if token.to_s.empty?
+
       text.to_s.gsub(token.to_s, "[REDACTED]")
     end
 

data/lib/kward/model/model_info.rb

@@ -128,6 +128,8 @@ module Kward
       return override_model if override_model
 
       case provider
+      when "Local"
+        env["KWARD_LOCAL_MODEL"] || ConfigFiles.config_value(config, "local_model")
       when "OpenRouter"
         env["OPENROUTER_MODEL"] || ConfigFiles.config_value(config, "openrouter_model", "model")
       when "Copilot"
@@ -175,6 +177,8 @@ module Kward
 
     def reasoning_effort(config:, env: ENV, provider: nil)
       case provider.to_s
+      when "Local"
+        nil
       when "OpenRouter"
         env["OPENROUTER_REASONING_EFFORT"] || ConfigFiles.config_value(config, "openrouter_reasoning_effort", "reasoning_effort", "thinking_level") || DEFAULT_REASONING_EFFORT
       when "Copilot"
@@ -191,6 +195,7 @@ module Kward
       when "openrouter" then "OpenRouter"
       when "copilot" then "Copilot"
       when "anthropic", "claude" then "Anthropic"
+      when "local" then "Local"
       when "codex", "openai" then "Codex"
       else provider.to_s
       end
@@ -201,6 +206,7 @@ module Kward
       when "openrouter" then "openrouter"
       when "copilot" then "copilot"
       when "anthropic", "claude" then "anthropic"
+      when "local" then "local"
       else "codex"
       end
     end
@@ -210,6 +216,7 @@ module Kward
       when "openrouter" then "openrouter_model"
       when "copilot" then "copilot_model"
       when "anthropic", "claude" then "anthropic_model"
+      when "local" then "local_model"
       else "openai_model"
       end
     end
@@ -219,6 +226,7 @@ module Kward
       when "openrouter" then "openrouter_reasoning_effort"
       when "copilot" then "copilot_reasoning_effort"
       when "anthropic", "claude" then "anthropic_reasoning_effort"
+      when "local" then "local_reasoning_effort"
       else "openai_reasoning_effort"
       end
     end
@@ -357,7 +365,9 @@ module Kward
       pattern_context_window(ANTHROPIC_CONTEXT_WINDOWS, normalize_anthropic_model(id))
     end
 
-    def supports_images?(_provider, id)
+    def supports_images?(provider, id)
+      return false if provider == "Local"
+
       IMAGE_UNSUPPORTED_MODELS.none? { |pattern| id.to_s.match?(pattern) }
     end
 

data/lib/kward/model/payloads.rb

@@ -26,6 +26,7 @@ module Kward
 
       payload = { model: parts[:model], messages: parts[:messages], tools: parts[:tools] }
       payload[:reasoning] = { effort: reasoning || reasoning_effort("OpenRouter") } if provider == "OpenRouter" && reasoning != false
+      payload[:stream] = true if provider == "Local"
       payload[:max_tokens] = max_tokens.to_i if max_tokens.to_i.positive?
       payload
     end

data/lib/kward/model/stream_parser.rb

@@ -13,36 +13,68 @@ module Kward
   module ModelStreamParser
     module_function
 
-    def parse_openai_chat_sse(body, on_assistant_delta: nil, usage_normalizer: nil)
-      content = +""
-      tool_calls = []
-      usage = nil
+    def parse_openai_chat_sse(body, on_assistant_delta: nil, usage_normalizer: nil, provider_label: "OpenAI-compatible provider")
+      state = openai_chat_sse_state
       body.split(/\r?\n\r?\n/).each do |block|
-        data = block.lines.filter_map { |line| line.start_with?("data:") ? line.delete_prefix("data:").strip : nil }.join("\n")
-        next if data.empty? || data == "[DONE]"
-
-        event = JSON.parse(data)
-        usage ||= usage_normalizer&.call(event["usage"])
-        choice = Array(event["choices"]).first || {}
-        delta = choice["delta"] || {}
-        if delta["content"]
-          text = delta["content"].to_s
-          content << text
-          on_assistant_delta&.call(text)
-        end
-        Array(delta["tool_calls"]).each do |tool_call|
-          merge_streaming_tool_call(tool_calls, tool_call)
+        process_openai_chat_sse_block(block, state, on_assistant_delta: on_assistant_delta, usage_normalizer: usage_normalizer)
+      end
+      openai_chat_sse_message(state)
+    rescue JSON::ParserError => e
+      raise "#{provider_label} returned invalid SSE JSON: #{e.message}"
+    end
+
+    # Incrementally parses a Chat Completions SSE HTTP response body. Local
+    # OpenAI-compatible servers stream this shape, so emit assistant deltas as
+    # complete SSE blocks arrive rather than waiting for connection close.
+    def parse_openai_chat_sse_stream(response, on_assistant_delta: nil, cancellation: nil, usage_normalizer: nil, provider_label: "OpenAI-compatible provider")
+      state = openai_chat_sse_state
+      buffer = +""
+
+      response.read_body do |chunk|
+        cancellation&.raise_if_cancelled!
+        buffer << chunk
+        while (index = buffer.index(/\r?\n\r?\n/))
+          delimiter = Regexp.last_match[0]
+          block = buffer[0...index]
+          buffer = buffer[(index + delimiter.length)..] || +""
+          process_openai_chat_sse_block(block, state, on_assistant_delta: on_assistant_delta, usage_normalizer: usage_normalizer)
         end
-        message = choice["message"] || {}
-        content << message["content"].to_s if content.empty? && message["content"]
-        Array(message["tool_calls"]).each { |tool_call| merge_streaming_tool_call(tool_calls, tool_call) }
       end
-      result = { "role" => "assistant", "content" => content }
-      result["tool_calls"] = finalized_streaming_tool_calls(tool_calls) unless tool_calls.empty?
-      result["usage"] = usage if usage
-      result
+      cancellation&.raise_if_cancelled!
+      process_openai_chat_sse_block(buffer, state, on_assistant_delta: on_assistant_delta, usage_normalizer: usage_normalizer) unless buffer.empty?
+      openai_chat_sse_message(state)
     rescue JSON::ParserError => e
-      raise "Copilot returned invalid SSE JSON: #{e.message}"
+      raise "#{provider_label} returned invalid SSE JSON: #{e.message}"
+    end
+
+    def openai_chat_sse_state
+      { content: +"", tool_calls: [], usage: nil }
+    end
+
+    def process_openai_chat_sse_block(block, state, on_assistant_delta: nil, usage_normalizer: nil)
+      data = block.lines.filter_map { |line| line.start_with?("data:") ? line.delete_prefix("data:").strip : nil }.join("\n")
+      return if data.empty? || data == "[DONE]"
+
+      event = JSON.parse(data)
+      state[:usage] ||= usage_normalizer&.call(event["usage"])
+      choice = Array(event["choices"]).first || {}
+      delta = choice["delta"] || {}
+      if delta["content"]
+        text = delta["content"].to_s
+        state[:content] << text
+        on_assistant_delta&.call(text)
+      end
+      Array(delta["tool_calls"]).each { |tool_call| merge_streaming_tool_call(state[:tool_calls], tool_call) }
+      message = choice["message"] || {}
+      state[:content] << message["content"].to_s if state[:content].empty? && message["content"]
+      Array(message["tool_calls"]).each { |tool_call| merge_streaming_tool_call(state[:tool_calls], tool_call) }
+    end
+
+    def openai_chat_sse_message(state)
+      result = { "role" => "assistant", "content" => state[:content] }
+      result["tool_calls"] = finalized_streaming_tool_calls(state[:tool_calls]) unless state[:tool_calls].empty?
+      result["usage"] = state[:usage] if state[:usage]
+      result
     end
 
     def parse_codex_sse(body, on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, show_raw_reasoning: false, usage_normalizer: nil, request_error_class: nil)

data/lib/kward/pan/index.html.erb

@@ -164,6 +164,7 @@
           <div class="title-row"><span class="live-dot"></span><h1 id="conversation-title">New session</h1></div>
           <div class="top-meta" id="session-meta">Secure LAN workspace</div>
         </div>
+        <button class="text-button" id="capture-skill" type="button">Capture skill</button>
         <button class="text-button" id="rename-session" type="button">Rename</button>
         <button class="text-button danger" id="delete-session" type="button">Delete</button>
       </header>
@@ -456,7 +457,56 @@
     document.getElementById('open-sessions').addEventListener('click', () => document.body.classList.add('sessions-open'));
     document.getElementById('close-sessions').addEventListener('click', closeSessions);
     document.getElementById('backdrop').addEventListener('click', closeSessions);
+    async function captureSkill() {
+      try {
+        const sourceResponse = await fetch('/skill-capture/sessions', { cache: 'no-store' });
+        const sourceData = await sourceResponse.json();
+        const candidates = sourceData.sessions || [];
+        if (!candidates.length) throw new Error('No saved sessions found.');
+        const choices = candidates.map((session, index) => `${index + 1}. ${session.name || session.firstMessage || 'Untitled session'}`).join('\n');
+        const answer = window.prompt(`Capture a personal skill from which saved session?\n\n${choices}`, '1');
+        if (answer === null) return;
+        const source = candidates[Number(answer) - 1];
+        if (!source) throw new Error('Choose a session number from the list.');
+        setStatus({ active: true, pending: 0 });
+        const draftResponse = await fetch('/skill-capture/draft', {
+          method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ sessionPath: source.path })
+        });
+        const draft = await draftResponse.json();
+        if (!draftResponse.ok || !draft.ok) throw new Error(draft.error || 'Could not create a skill draft.');
+        reviewSkillDraft(draft.content);
+      } catch (error) {
+        showError(error.message);
+      } finally {
+        setStatus({ active: false, pending: 0 });
+      }
+    }
+
+    function reviewSkillDraft(content) {
+      const overlay = document.createElement('div');
+      overlay.style.cssText = 'position:fixed;inset:0;z-index:50;display:grid;place-items:center;padding:1rem;background:#000b';
+      const panel = document.createElement('section');
+      panel.style.cssText = 'display:grid;gap:.8rem;width:min(58rem,100%);max-height:90dvh;padding:1rem;border:1px solid var(--line-bright);border-radius:12px;background:var(--panel)';
+      const heading = document.createElement('strong'); heading.textContent = 'Review captured skill';
+      const note = document.createElement('p'); note.style.margin = '0'; note.style.color = 'var(--muted)'; note.textContent = 'Edit the draft. Saving writes a personal skill but does not activate it.';
+      const editor = document.createElement('textarea'); editor.value = content; editor.style.cssText = 'min-height:55dvh;resize:vertical;padding:.75rem;border:1px solid var(--line);border-radius:8px;background:var(--bg);color:var(--ink);font-family:ui-monospace,monospace;font-size:.8rem';
+      const actions = document.createElement('div'); actions.style.cssText = 'display:flex;justify-content:flex-end;gap:.6rem';
+      const cancel = document.createElement('button'); cancel.className = 'text-button'; cancel.textContent = 'Cancel';
+      const save = document.createElement('button'); save.className = 'new-session'; save.style.margin = '0'; save.textContent = 'Save personal skill';
+      cancel.onclick = () => overlay.remove();
+      save.onclick = async () => {
+        const request = async overwrite => fetch('/skill-capture/save', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ content: editor.value, overwrite }) });
+        let response = await request(false); let result = await response.json();
+        if (response.status === 409 && window.confirm(`${result.error}\n\nOverwrite it?`)) { response = await request(true); result = await response.json(); }
+        if (!response.ok || !result.ok) { showError(result.error || 'Could not save the skill.'); return; }
+        overlay.remove();
+        window.alert(`Saved personal skill: ${result.path}`);
+      };
+      actions.append(cancel, save); panel.append(heading, note, editor, actions); overlay.append(panel); document.body.append(overlay); editor.focus();
+    }
+
     document.getElementById('new-session').addEventListener('click', () => changeSession('new'));
+    document.getElementById('capture-skill').addEventListener('click', captureSkill);
     document.getElementById('rename-session').addEventListener('click', () => {
       if (!activeSession) return;
       const name = window.prompt('Session name', activeSession.name || '');

data/lib/kward/pan/server.rb

@@ -13,11 +13,12 @@ require_relative "../plugin_registry"
 require_relative "../prompts/commands"
 require_relative "../rpc/transcript_normalizer"
 require_relative "../session_store"
+require_relative "../skills/capture"
 require_relative "../session_trash"
 require_relative "../tools/tool_call"
 require_relative "../tools/registry"
 require_relative "../version"
-require_relative "../workspace"
+require_relative "../workspace_factory"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -33,7 +34,11 @@ module Kward
       @client = client
       @output = output
       @udp_socket_class = udp_socket_class
-      @workspace = Workspace.new(root: working_directory)
+      @workspace = WorkspaceFactory.build(
+        root: working_directory,
+        guardrails: ConfigFiles.workspace_guardrails_enabled?(config),
+        config: config
+      )
       @full_config = config
       @config = pan_config(config)
       @host = @config.fetch("host", DEFAULT_HOST).to_s
@@ -234,12 +239,18 @@ module Kward
         write_json(socket, 200, transcript: transcript_items, session: active_session_payload, workspace: @workspace.root.to_s)
       when ["GET", "/sessions"]
         write_json(socket, 200, sessions: session_payloads, activeSessionId: @session.id)
+      when ["GET", "/skill-capture/sessions"]
+        write_json(socket, 200, sessions: skill_capture_sessions)
       when ["GET", "/events"]
         stream_events(socket)
       when ["POST", "/turn"]
         handle_turn(socket, request[:body], request[:headers])
       when ["POST", "/sessions"]
         handle_session_action(socket, request[:body], request[:headers])
+      when ["POST", "/skill-capture/draft"]
+        handle_skill_capture_draft(socket, request[:body], request[:headers])
+      when ["POST", "/skill-capture/save"]
+        handle_skill_capture_save(socket, request[:body], request[:headers])
       else
         write_response(socket, 404, { "Content-Type" => "text/plain; charset=utf-8" }, "Not found\n")
       end
@@ -308,6 +319,42 @@ module Kward
       write_json(socket, 400, ok: false, error: "Invalid JSON")
     end
 
+    def handle_skill_capture_draft(socket, body, headers)
+      return write_json(socket, 415, ok: false, error: "Content-Type must be application/json") unless json_request?(headers)
+
+      params = JSON.parse(body.empty? ? "{}" : body)
+      draft = skill_capture.generate(params.fetch("sessionPath"))
+      write_json(socket, 200, ok: true, content: draft.content, sourcePath: draft.source_path, name: draft.name, description: draft.description)
+    rescue JSON::ParserError
+      write_json(socket, 400, ok: false, error: "Invalid JSON")
+    rescue Skills::Capture::Error => error
+      write_json(socket, 422, ok: false, error: error.message)
+    end
+
+    def handle_skill_capture_save(socket, body, headers)
+      return write_json(socket, 415, ok: false, error: "Content-Type must be application/json") unless json_request?(headers)
+
+      params = JSON.parse(body.empty? ? "{}" : body)
+      draft = skill_capture.save(params.fetch("content"), overwrite: params["overwrite"] == true)
+      write_json(socket, 200, ok: true, path: skill_capture.skill_path(draft.name), name: draft.name, description: draft.description)
+    rescue JSON::ParserError
+      write_json(socket, 400, ok: false, error: "Invalid JSON")
+    rescue Skills::Capture::ConflictError => error
+      write_json(socket, 409, ok: false, error: error.message)
+    rescue Skills::Capture::Error => error
+      write_json(socket, 422, ok: false, error: error.message)
+    end
+
+    def skill_capture_sessions
+      @session_store.capture_candidates.map do |session|
+        { path: session.path, name: session.name, firstMessage: session.first_message, workspaceRoot: session.cwd, modifiedAt: session.modified_at.utc.iso8601(3) }
+      end
+    end
+
+    def skill_capture
+      @skill_capture ||= Skills::Capture.new(session_store: @session_store, client: @client, config_dir: @session_store.config_dir)
+    end
+
     def update_session(params)
       return { status: 409, ok: false, error: "Wait for queued turns to finish before changing sessions" } if turns_pending?
 

data/lib/kward/plugin_registry.rb

@@ -401,7 +401,7 @@ module Kward
       previous_path = self.class.loading_path
       self.class.loading_registry = self
       self.class.loading_path = path
-      Kernel.load(path)
+      Kernel.load(path, true)
       @paths << path
     rescue StandardError => e
       warn "Warning: skipping Kward plugin #{path}: #{e.message}"

data/lib/kward/prompt_interface/editor/controller.rb

@@ -153,11 +153,11 @@ module Kward
             pending_deletions << line[1..].to_s
           elsif line.start_with?("+")
             deleted = pending_deletions.shift
-            rows << side_by_side_diff_row(deleted && "- #{deleted}", "+ #{line[1..]}", width)
+            rows.concat(side_by_side_diff_rows(deleted && "- #{deleted}", "+ #{line[1..]}", width))
           else
             rows.concat(flush_side_by_side_deletions(pending_deletions, width))
             text = line.start_with?(" ") ? line[1..].to_s : line
-            rows << side_by_side_diff_row("  #{text}", "  #{text}", width)
+            rows.concat(side_by_side_diff_rows("  #{text}", "  #{text}", width))
           end
         end
 
@@ -170,7 +170,17 @@ module Kward
       end
 
       def flush_side_by_side_deletions(lines, width)
-        lines.shift(lines.length).map { |line| side_by_side_diff_row("- #{line}", nil, width) }
+        lines.shift(lines.length).flat_map { |line| side_by_side_diff_rows("- #{line}", nil, width) }
+      end
+
+      def side_by_side_diff_rows(left, right, width)
+        return [side_by_side_diff_row(left, right, width)] unless current_editor_soft_wrap?
+
+        left_lines = side_by_side_diff_cell_lines(left, width)
+        right_lines = side_by_side_diff_cell_lines(right, width)
+        [left_lines.length, right_lines.length].max.times.map do |index|
+          side_by_side_diff_row(left_lines[index], right_lines[index], width)
+        end
       end
 
       def side_by_side_diff_row(left, right, width)
@@ -184,6 +194,17 @@ module Kward
         visible_truncate(value, width)
       end
 
+      def side_by_side_diff_cell_lines(text, width)
+        return [""] if text.nil?
+
+        value = text.to_s
+        prefix = value.start_with?("- ", "+ ", "  ") ? value[0, 2] : ""
+        content = value.delete_prefix(prefix)
+        return [prefix] if content.empty?
+
+        content.chars.each_slice([width - prefix.length, 1].max).map { |characters| "#{prefix}#{characters.join}" }
+      end
+
       def side_by_side_diff_column_width
         content_width = [screen_width - 4, 1].max
         gutter_width = [[999.to_s.length, 4].max + 3, 1].max
@@ -220,6 +241,7 @@ module Kward
         @editor_text_width = nil
         @editor_save_as_active = false
         @editor_save_as_buffer = ""
+        @editor_save_callback = nil
         @editor_state = nil
         @prompt_label = "You>"
         self.composer_input = ""
@@ -1150,6 +1172,17 @@ module Kward
           return true
         end
 
+        if @editor_save_callback
+          result = @editor_save_callback.call(@editor_state.buffer)
+          if result.to_s.empty?
+            close_editor
+            return true
+          end
+
+          @editor_state.status = result.to_s
+          return false
+        end
+
         if path.to_s.strip.empty? && @editor_state.path.to_s.empty?
           if prompt_for_path
             begin_editor_save_as