kward 0.78.0 → 0.80.0

data/lib/kward/model/stream_parser.rb

@@ -13,47 +13,79 @@ 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 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)
+    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, provider_label: "Codex", on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, show_raw_reasoning: false, usage_normalizer: nil, request_error_class: nil)
       state = codex_sse_state(show_raw_reasoning: show_raw_reasoning)
       body.split(/\r?\n\r?\n/).each do |block|
-        process_codex_sse_block(block, state, on_reasoning_delta: on_reasoning_delta, on_reasoning_boundary: on_reasoning_boundary, on_assistant_delta: on_assistant_delta, usage_normalizer: usage_normalizer, request_error_class: request_error_class)
+        process_codex_sse_block(block, state, provider_label: provider_label, on_reasoning_delta: on_reasoning_delta, on_reasoning_boundary: on_reasoning_boundary, on_assistant_delta: on_assistant_delta, usage_normalizer: usage_normalizer, request_error_class: request_error_class)
       end
       flush_codex_reasoning_delta(state, on_reasoning_delta: on_reasoning_delta)
       codex_sse_message(state)
     rescue JSON::ParserError => e
-      raise "Codex OAuth returned invalid SSE JSON: #{e.message}"
+      raise "#{provider_label} returned invalid SSE JSON: #{e.message}"
     end
 
     # Incrementally parses a Codex/Responses SSE HTTP response body.
@@ -61,7 +93,7 @@ module Kward
     # Deltas are yielded as soon as complete SSE blocks arrive so interactive
     # frontends can render streamed assistant and reasoning text without waiting
     # for the provider to close the response.
-    def parse_codex_sse_stream(response, on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, cancellation: nil, show_raw_reasoning: false, usage_normalizer: nil, request_error_class: nil)
+    def parse_codex_sse_stream(response, provider_label: "Codex", on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, cancellation: nil, show_raw_reasoning: false, usage_normalizer: nil, request_error_class: nil)
       state = codex_sse_state(show_raw_reasoning: show_raw_reasoning)
       buffer = +""
 
@@ -72,15 +104,15 @@ module Kward
           delimiter = Regexp.last_match[0]
           block = buffer[0...index]
           buffer = buffer[(index + delimiter.length)..] || +""
-          process_codex_sse_block(block, state, on_reasoning_delta: on_reasoning_delta, on_reasoning_boundary: on_reasoning_boundary, on_assistant_delta: on_assistant_delta, usage_normalizer: usage_normalizer, request_error_class: request_error_class)
+          process_codex_sse_block(block, state, provider_label: provider_label, on_reasoning_delta: on_reasoning_delta, on_reasoning_boundary: on_reasoning_boundary, on_assistant_delta: on_assistant_delta, usage_normalizer: usage_normalizer, request_error_class: request_error_class)
         end
       end
       cancellation&.raise_if_cancelled!
-      process_codex_sse_block(buffer, state, on_reasoning_delta: on_reasoning_delta, on_reasoning_boundary: on_reasoning_boundary, on_assistant_delta: on_assistant_delta, usage_normalizer: usage_normalizer, request_error_class: request_error_class) unless buffer.empty?
+      process_codex_sse_block(buffer, state, provider_label: provider_label, on_reasoning_delta: on_reasoning_delta, on_reasoning_boundary: on_reasoning_boundary, on_assistant_delta: on_assistant_delta, usage_normalizer: usage_normalizer, request_error_class: request_error_class) unless buffer.empty?
       flush_codex_reasoning_delta(state, on_reasoning_delta: on_reasoning_delta)
       codex_sse_message(state)
     rescue JSON::ParserError => e
-      raise "Codex OAuth returned invalid SSE JSON: #{e.message}"
+      raise "#{provider_label} returned invalid SSE JSON: #{e.message}"
     end
 
     def parse_anthropic_sse_stream(response, on_reasoning_delta: nil, on_assistant_delta: nil, cancellation: nil, usage_normalizer: nil, request_error_class: nil)
@@ -103,6 +135,71 @@ module Kward
       raise "Anthropic returned invalid SSE JSON: #{e.message}"
     end
 
+    def parse_gemini_sse_stream(response, on_assistant_delta: nil, cancellation: nil, usage_normalizer: nil)
+      state = { content: +"", calls: {}, usage: nil }
+      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_gemini_sse_block(block, state, on_assistant_delta: on_assistant_delta, cancellation: cancellation, usage_normalizer: usage_normalizer)
+        end
+      end
+      cancellation&.raise_if_cancelled!
+      process_gemini_sse_block(buffer, state, on_assistant_delta: on_assistant_delta, cancellation: cancellation, usage_normalizer: usage_normalizer) unless buffer.empty?
+      gemini_sse_message(state)
+    rescue JSON::ParserError => e
+      raise "Google Gemini returned invalid SSE JSON: #{e.message}"
+    end
+
+    def process_gemini_sse_block(block, state, on_assistant_delta:, cancellation:, usage_normalizer:)
+      data = block.lines.filter_map { |line| line.start_with?("data:") ? line.delete_prefix("data:").strip : nil }.join("\n")
+      return if data.empty? || data == "[DONE]"
+
+      cancellation&.raise_if_cancelled!
+      event = JSON.parse(data)
+      Array(event["candidates"]).each_with_index do |candidate, candidate_index|
+        Array(candidate.dig("content", "parts")).each_with_index do |part, part_index|
+          text = part["text"].to_s
+          unless text.empty?
+            state[:content] << text
+            on_assistant_delta&.call(text)
+          end
+          merge_gemini_function_call(state[:calls], part["functionCall"], candidate_index: candidate_index, part_index: part_index)
+        end
+      end
+      state[:usage] = usage_normalizer&.call(event["usageMetadata"]) || state[:usage]
+    end
+
+    def merge_gemini_function_call(calls, function_call, candidate_index:, part_index:)
+      return unless function_call.is_a?(Hash)
+
+      key = function_call["id"] || "#{candidate_index}:#{part_index}:#{function_call["name"]}"
+      call = calls[key] ||= { "id" => function_call["id"] || "call_gemini_#{candidate_index}_#{part_index}", "name" => function_call["name"].to_s, "args" => {}, "args_buffer" => +"" }
+      call["name"] = function_call["name"].to_s unless function_call["name"].to_s.empty?
+      args = function_call["args"]
+      if args.is_a?(Hash)
+        call["args"].merge!(args)
+      elsif !args.nil?
+        call["args_buffer"] << args.to_s
+      end
+    end
+
+    def gemini_sse_message(state)
+      message = { "role" => "assistant", "content" => state[:content] }
+      unless state[:calls].empty?
+        message["tool_calls"] = state[:calls].values.map do |call|
+          arguments = call["args_buffer"].empty? ? JSON.dump(call["args"]) : call["args_buffer"]
+          { "id" => call["id"], "type" => "function", "function" => { "name" => call["name"], "arguments" => arguments } }
+        end
+      end
+      message["usage"] = state[:usage] if state[:usage]
+      message
+    end
+
     def anthropic_sse_state
       { content: +"", reasoning_summary: +"", blocks: {}, tool_calls: [], usage: nil }
     end
@@ -201,7 +298,7 @@ module Kward
 
     def merge_streaming_tool_call(tool_calls, delta)
       index = (delta["index"] || tool_calls.length).to_i
-      tool_calls[index] ||= { "id" => nil, "type" => "function", "function" => { "name" => "", "arguments" => "" } }
+      tool_calls[index] ||= { "id" => nil, "type" => "function", "function" => { "name" => +"", "arguments" => +"" } }
       current = tool_calls[index]
       current["id"] = delta["id"] if delta["id"]
       current["type"] = delta["type"] if delta["type"]
@@ -239,7 +336,7 @@ module Kward
       }
     end
 
-    def process_codex_sse_block(block, state, on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, usage_normalizer: nil, request_error_class: nil)
+    def process_codex_sse_block(block, state, provider_label: "Codex", on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, usage_normalizer: nil, request_error_class: 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]"
 
@@ -277,11 +374,11 @@ module Kward
           end
         end
       when "response.failed", "response.incomplete"
-        raise codex_sse_error(event, request_error_class: request_error_class)
+        raise codex_sse_error(event, provider_label: provider_label, request_error_class: request_error_class)
       end
     end
 
-    def codex_sse_error(event, request_error_class: nil)
+    def codex_sse_error(event, provider_label: "Codex", request_error_class: nil)
       response = event["response"]
       error = event["error"] || (response["error"] if response.is_a?(Hash)) || {}
       message = if error.is_a?(Hash)
@@ -292,7 +389,7 @@ module Kward
       message = event["type"].to_s if message.empty?
       code = error.is_a?(Hash) && error["code"].to_s == "server_error" ? 500 : 400
       if request_error_class
-        request_error_class.new(provider: "Codex", code: code, body: "#{event["type"]}: #{message}")
+        request_error_class.new(provider: provider_label, code: code, body: "#{event["type"]}: #{message}")
       else
         "#{event["type"]}: #{message}"
       end
@@ -332,6 +429,10 @@ module Kward
         part["type"] ||= "output_text"
         text_key = part["type"] == "refusal" ? "refusal" : "text"
         part[text_key] = part[text_key].to_s + text
+        if codex_streamable_message_item?(item)
+          on_assistant_delta&.call(text)
+          state[:emitted_message_keys] << codex_item_key(item)
+        end
       end
       state[:raw_content] << text
     end
@@ -669,7 +770,8 @@ module Kward
     end
 
     def codex_streamable_message_item?(item)
-      codex_message_phase(item) == "final_answer"
+      phase = codex_message_phase(item)
+      phase.empty? || phase == "final_answer"
     end
 
     def codex_message_phase(item)

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/permissions/policy.rb

@@ -13,6 +13,7 @@ module Kward
       MODES = %w[ask read-only workspace-write deny-by-default].freeze
       NETWORK_TOOLS = %w[web_search fetch_content fetch_raw].freeze
       FILE_CHANGE_TOOLS = %w[write_file edit_file].freeze
+      MUTATING_TOOLS = (FILE_CHANGE_TOOLS + ["git_commit"]).freeze
 
       Decision = Struct.new(:action, :reason, keyword_init: true) do
         def allowed?
@@ -96,13 +97,15 @@ module Kward
       def request_for(tool_name, arguments, source:)
         name = tool_name.to_s
         args = arguments.to_h
-        {
+        request = {
           "tool" => name,
           "path" => args["path"] || args[:path],
           "host" => request_host(name, args),
           "command" => args["command"] || args[:command],
           "source" => source.to_s
         }.compact.transform_values(&:to_s)
+        request["paths"] = args["paths"] || args[:paths] if name == "git_commit"
+        request
       end
 
       def request_host(name, arguments)
@@ -135,11 +138,11 @@ module Kward
         return Decision.new(action: :deny, reason: "read-only mode") if @mode == "read-only" && risky?(request)
         return Decision.new(action: :deny, reason: "deny-by-default mode") if @mode == "deny-by-default" && risky?(request)
 
-        if file_change?(request) && outside_write_scopes?(request)
+        if mutating?(request) && outside_write_scopes?(request)
           return Decision.new(action: :deny, reason: "path outside write scopes")
         end
 
-        if @mode == "workspace-write" && file_change?(request)
+        if @mode == "workspace-write" && mutating?(request)
           return Decision.new(action: :allow, reason: "workspace write mode")
         end
 
@@ -152,17 +155,28 @@ module Kward
         FILE_CHANGE_TOOLS.include?(request.fetch("tool"))
       end
 
+      def mutating?(request)
+        MUTATING_TOOLS.include?(request.fetch("tool"))
+      end
+
       def network?(request)
         NETWORK_TOOLS.include?(request.fetch("tool")) || request["source"] == "mcp"
       end
 
       def risky?(request)
-        file_change?(request) || request.fetch("tool") == "run_shell_command" || network?(request)
+        mutating?(request) || request.fetch("tool") == "run_shell_command" || network?(request)
       end
 
       def outside_write_scopes?(request)
         return false if @write_scopes.nil?
 
+        if request.fetch("tool") == "git_commit"
+          paths = request["paths"]
+          return true unless paths.is_a?(Array) && !paths.empty?
+
+          return paths.any? { |path| !@write_scopes.any? { |scope| glob_match?(scope, path) } }
+        end
+
         path = request["path"]
         path.nil? || !@write_scopes.any? { |scope| glob_match?(scope, path) }
       end