kward 0.74.0 → 0.75.0

data/lib/kward/model/stream_parser.rb

@@ -45,11 +45,12 @@ module Kward
       raise "Copilot returned invalid SSE JSON: #{e.message}"
     end
 
-    def parse_codex_sse(body, on_reasoning_delta: nil, on_assistant_delta: nil, usage_normalizer: nil, request_error_class: nil)
-      state = codex_sse_state
+    def parse_codex_sse(body, on_reasoning_delta: 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_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}"
@@ -60,8 +61,8 @@ 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_assistant_delta: nil, cancellation: nil, usage_normalizer: nil, request_error_class: nil)
-      state = codex_sse_state
+    def parse_codex_sse_stream(response, on_reasoning_delta: 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 = +""
 
       response.read_body do |chunk|
@@ -76,6 +77,7 @@ module Kward
       end
       cancellation&.raise_if_cancelled!
       process_codex_sse_block(buffer, state, on_reasoning_delta: on_reasoning_delta, 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}"
@@ -218,17 +220,21 @@ module Kward
       end
     end
 
-    def codex_sse_state
+    def codex_sse_state(show_raw_reasoning: false)
       {
         content: +"",
         raw_content: +"",
         emitted_message_keys: [],
         reasoning_summary: +"",
+        raw_reasoning_visible: +"",
+        pending_reasoning_delta: +"",
+        show_raw_reasoning: show_raw_reasoning,
         tool_calls: [],
         response_item_keys: [],
         items_by_id: {},
         active_item_id: nil,
         current_text_content_part: nil,
+        current_reasoning_content_part: nil,
         usage: nil
       }
     end
@@ -252,7 +258,9 @@ module Kward
       when "response.reasoning_summary_part.done"
         codex_reasoning_part_done(state, on_reasoning_delta: on_reasoning_delta)
       when "response.reasoning_text.delta"
-        codex_reasoning_delta(state, event["delta"], on_reasoning_delta: on_reasoning_delta)
+        codex_raw_reasoning_delta(state, event["delta"], on_reasoning_delta: on_reasoning_delta)
+      when "response.reasoning_text.done"
+        codex_raw_reasoning_done(state, event["text"], on_reasoning_delta: on_reasoning_delta)
       when "response.function_call_arguments.delta", "response.custom_tool_call_input.delta"
         codex_tool_arguments_delta(state, event["delta"])
       when "response.function_call_arguments.done"
@@ -299,6 +307,7 @@ module Kward
       remember_codex_item(state, item)
       state[:active_item_id] = codex_item_key(item)
       state[:current_text_content_part] = nil
+      state[:current_reasoning_content_part] = nil
     end
 
     def codex_content_part_added(state, part)
@@ -333,20 +342,53 @@ module Kward
 
       item["summary"] ||= []
       item["summary"] << deep_dup_hash(part)
+      state[:current_reasoning_content_part] = nil
     end
 
     def codex_reasoning_delta(state, delta, on_reasoning_delta: nil)
+      text = visible_codex_reasoning_delta(state, delta)
+      return if text.empty?
+
+      append_codex_reasoning_text(state, text, on_reasoning_delta: on_reasoning_delta)
+    end
+
+    def codex_raw_reasoning_delta(state, delta, on_reasoning_delta: nil)
       text = delta.to_s
       return if text.empty?
 
       item = active_codex_item(state)
-      if item&.fetch("type", nil) == "reasoning"
-        item["summary"] ||= []
-        item["summary"] << { "type" => "summary_text", "text" => +"" } if item["summary"].empty?
-        item["summary"].last["text"] = item["summary"].last["text"].to_s + text
+      if item&.fetch("type", nil) == "reasoning" && state[:show_raw_reasoning]
+        item["content"] ||= [{ "type" => "reasoning_text", "text" => +"" }]
+        part = state[:current_reasoning_content_part] || item["content"].last
+        part = item["content"].last unless part.is_a?(Hash)
+        part["type"] ||= "reasoning_text"
+        part["text"] = part["text"].to_s + text
+        state[:current_reasoning_content_part] = part
       end
-      state[:reasoning_summary] << text
-      on_reasoning_delta&.call(text)
+      return unless state[:show_raw_reasoning]
+
+      visible = visible_codex_reasoning_delta(state, text)
+      append_codex_raw_reasoning_text(state, visible, on_reasoning_delta: on_reasoning_delta) unless visible.empty?
+    end
+
+    def codex_raw_reasoning_done(state, text, on_reasoning_delta: nil)
+      item = active_codex_item(state)
+      full_text = text.to_s
+      if item&.fetch("type", nil) == "reasoning" && state[:show_raw_reasoning]
+        item["content"] ||= [{ "type" => "reasoning_text", "text" => +"" }]
+        part = state[:current_reasoning_content_part] || item["content"].last
+        part = item["content"].last unless part.is_a?(Hash)
+        part["type"] ||= "reasoning_text"
+        part["text"] = full_text
+        state[:current_reasoning_content_part] = part
+      end
+      return unless state[:show_raw_reasoning]
+
+      flush_codex_reasoning_delta(state, on_reasoning_delta: on_reasoning_delta)
+      visible = sanitize_codex_reasoning_text(full_text)
+      emitted = state[:raw_reasoning_visible]
+      text = visible.start_with?(emitted) ? visible[emitted.length..].to_s : (emitted.empty? ? visible : +"")
+      append_codex_raw_reasoning_text(state, text, on_reasoning_delta: on_reasoning_delta) unless text.empty?
     end
 
     def codex_reasoning_part_done(state, on_reasoning_delta: nil)
@@ -354,12 +396,97 @@ module Kward
       return unless item&.fetch("type", nil) == "reasoning"
       return if item["summary"].to_a.empty?
 
+      flush_codex_reasoning_delta(state, on_reasoning_delta: on_reasoning_delta)
       text = "\n\n"
       item["summary"].last["text"] = item["summary"].last["text"].to_s + text
       state[:reasoning_summary] << text
       on_reasoning_delta&.call(text)
     end
 
+    def append_codex_reasoning_text(state, text, on_reasoning_delta: nil)
+      text = compact_codex_reasoning_delta_spacing(state[:reasoning_summary], text)
+      return if text.empty?
+
+      item = active_codex_item(state)
+      if item&.fetch("type", nil) == "reasoning"
+        item["summary"] ||= []
+        item["summary"] << { "type" => "summary_text", "text" => +"" } if item["summary"].empty?
+        item["summary"].last["text"] = item["summary"].last["text"].to_s + text
+      end
+      state[:reasoning_summary] << text
+      on_reasoning_delta&.call(text)
+    end
+
+    def append_codex_raw_reasoning_text(state, text, on_reasoning_delta: nil)
+      text = compact_codex_reasoning_delta_spacing(state[:reasoning_summary], text)
+      return if text.empty?
+
+      state[:raw_reasoning_visible] << text
+      state[:reasoning_summary] << text
+      on_reasoning_delta&.call(text)
+    end
+
+    def visible_codex_reasoning_delta(state, delta)
+      state[:pending_reasoning_delta] << delta.to_s
+      sanitized = sanitize_codex_reasoning_text(state[:pending_reasoning_delta], keep_incomplete_comment: true)
+      text, pending_prefix = split_trailing_comment_prefix(sanitized[:text])
+      state[:pending_reasoning_delta].replace(pending_prefix + sanitized[:pending])
+      text
+    end
+
+    def flush_codex_reasoning_delta(state, on_reasoning_delta: nil)
+      pending = state[:pending_reasoning_delta].to_s
+      state[:pending_reasoning_delta].clear
+      text = sanitize_codex_reasoning_text(pending)
+      append_codex_raw_reasoning_text(state, text, on_reasoning_delta: on_reasoning_delta) unless text.empty?
+    end
+
+    def split_trailing_comment_prefix(text)
+      string = text.to_s
+      prefix = ["<!-", "<!", "<"].find { |candidate| string.end_with?(candidate) }
+      return [string, +""] unless prefix
+
+      [string[0...-prefix.length], prefix.dup]
+    end
+
+    def sanitize_codex_reasoning_text(text, keep_incomplete_comment: false)
+      string = text.to_s
+      visible = +""
+      index = 0
+
+      while (start_index = string.index("<!--", index))
+        end_index = string.index("-->", start_index + 4)
+        if end_index
+          visible << string[index...start_index]
+          index = end_index + 3
+        elsif keep_incomplete_comment
+          visible << string[index...start_index]
+          return { text: visible, pending: string[start_index..] }
+        else
+          visible << string[index..]
+          index = string.length
+        end
+      end
+
+      visible << string[index..].to_s
+      visible = compact_blank_codex_reasoning_lines(visible)
+      keep_incomplete_comment ? { text: visible, pending: +"" } : visible
+    end
+
+    def compact_blank_codex_reasoning_lines(text)
+      text.to_s.gsub(/(?:[ \t]*\n){3,}/, "\n\n")
+    end
+
+    def compact_codex_reasoning_delta_spacing(existing, text)
+      text = compact_blank_codex_reasoning_lines(text)
+      trailing_newlines = existing.to_s[/\n+\z/].to_s.length
+      leading_newlines = text[/\A\n+/].to_s.length
+      excess_newlines = trailing_newlines + leading_newlines - 2
+      return text unless excess_newlines.positive? && leading_newlines.positive?
+
+      text[[excess_newlines, leading_newlines].min..].to_s
+    end
+
     def codex_tool_arguments_delta(state, delta)
       item = active_codex_item(state)
       return unless item && ["function_call", "custom_tool_call"].include?(item["type"])
@@ -379,10 +506,40 @@ module Kward
       return unless item.is_a?(Hash)
 
       item = merge_codex_item(active_or_known_codex_item(state, item), item)
+      item = codex_visible_reasoning_item(state, item)
       remember_codex_item(state, item)
       collect_codex_item_output(state, item, on_assistant_delta: on_assistant_delta, on_reasoning_delta: on_reasoning_delta)
       state[:active_item_id] = nil if state[:active_item_id] == codex_item_key(item)
       state[:current_text_content_part] = nil
+      state[:current_reasoning_content_part] = nil
+    end
+
+    def codex_visible_reasoning_item(state, item)
+      return item unless item.is_a?(Hash) && item["type"] == "reasoning"
+
+      visible = deep_dup_hash(item)
+      sanitize_codex_reasoning_summary_item(visible)
+      visible.delete("content") unless state[:show_raw_reasoning]
+      return visible unless state[:show_raw_reasoning]
+      return visible if visible["summary"].is_a?(Array) && !visible["summary"].empty?
+
+      text = sanitize_codex_reasoning_text(raw_reasoning_from_codex_items([visible]))
+      visible["summary"] = [{ "type" => "summary_text", "text" => text }] unless text.empty?
+      visible
+    end
+
+    def sanitize_codex_reasoning_summary_item(item)
+      return unless item["summary"].is_a?(Array)
+
+      pending = +""
+      item["summary"].each do |part|
+        next unless part.is_a?(Hash) && part.key?("text")
+
+        pending << part["text"].to_s
+        sanitized = sanitize_codex_reasoning_text(pending, keep_incomplete_comment: true)
+        part["text"] = sanitized[:text]
+        pending.replace(sanitized[:pending])
+      end
     end
 
     def collect_codex_item_output(state, item, on_assistant_delta: nil, on_reasoning_delta: nil)
@@ -398,7 +555,7 @@ module Kward
           state[:emitted_message_keys] << key
         end
       when "reasoning"
-        text = reasoning_summary_from_codex_items([item])
+        text = sanitize_codex_reasoning_text(reasoning_summary_from_codex_items([item]))
         if state[:reasoning_summary].empty? && !text.empty?
           state[:reasoning_summary] << text
           on_reasoning_delta&.call(text)
@@ -563,5 +720,13 @@ module Kward
         end
       end.join
     end
+
+    def raw_reasoning_from_codex_items(items)
+      items.flat_map do |item|
+        next [] unless item.is_a?(Hash) && item["type"] == "reasoning" && item["content"].is_a?(Array)
+
+        item["content"].filter_map { |part| part["text"] if part.is_a?(Hash) && part["type"] == "reasoning_text" }
+      end.join
+    end
   end
 end

data/lib/kward/pan/server.rb

@@ -9,6 +9,8 @@ require_relative "../agent"
 require_relative "../config_files"
 require_relative "../events"
 require_relative "../model/retry_message"
+require_relative "../plugin_registry"
+require_relative "../prompts/commands"
 require_relative "../rpc/transcript_normalizer"
 require_relative "../session_store"
 require_relative "../tools/tool_call"
@@ -42,10 +44,14 @@ module Kward
         reasoning_effort: (@client.current_reasoning_effort if @client.respond_to?(:current_reasoning_effort))
       )
       @session.attach(@conversation)
+      hook_context = lifecycle_hook_context
+      hook_manager = lifecycle_hook_manager
       @agent = Agent.new(
         client: @client,
-        tool_registry: ToolRegistry.new(workspace: @workspace, ask_user_question_enabled: false),
-        conversation: @conversation
+        tool_registry: ToolRegistry.new(workspace: @workspace, ask_user_question_enabled: false, hook_manager: hook_manager, hook_context: hook_context),
+        conversation: @conversation,
+        hook_manager: hook_manager,
+        hook_context: hook_context
       )
       @prompt_queue = Queue.new
       @subscribers = []
@@ -97,6 +103,49 @@ module Kward
 
     private
 
+    def lifecycle_hook_manager
+      manager = Hooks::ConfigLoader.new(ConfigFiles.lifecycle_hooks_config(@workspace.root)).manager
+      manager.on_result = method(:broadcast_lifecycle_hook_event)
+      plugin_registry.hook_handlers.each do |hook|
+        manager.register(hook.event, id: hook.id, source: hook.path, order: hook.order, match: hook.match, failure_policy: hook.failure_policy) do |event, context|
+          hook.handler.call(event, context)
+        end
+      end
+      manager
+    end
+
+    def broadcast_lifecycle_hook_event(event, result)
+      broadcast("hook_event", {
+        event: {
+          id: event.id,
+          name: event.name,
+          phase: event.phase,
+          timestamp: event.timestamp.iso8601,
+          payloadKeys: event.payload.keys.map(&:to_s).sort
+        },
+        result: {
+          decision: result.decision.decision,
+          warnings: result.warnings,
+          messages: result.messages,
+          decisionCount: result.decisions.length
+        }
+      })
+    end
+
+    def lifecycle_hook_context
+      PluginRegistry::Context.new(
+        conversation: @conversation,
+        args: "",
+        session: @session,
+        workspace_root: @workspace.root.to_s,
+        say_callback: lambda { |message| broadcast("hook_message", { message: message.to_s }) }
+      )
+    end
+
+    def plugin_registry
+      @plugin_registry ||= PluginRegistry.load(reserved_commands: PromptCommands::BUILTIN_RESERVED_COMMAND_NAMES)
+    end
+
     def start_worker
       return if @worker_started
 

data/lib/kward/path_guard.rb

@@ -0,0 +1,13 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Shared path containment predicate for local filesystem guardrails.
+  module PathGuard
+    module_function
+
+    def inside?(path, root)
+      path = path.to_s
+      root = root.to_s
+      path == root || path.start_with?(root + File::SEPARATOR)
+    end
+  end
+end

data/lib/kward/plugin_registry.rb

@@ -1,4 +1,6 @@
 require_relative "config_files"
+require_relative "deep_copy"
+require_relative "hooks"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -39,6 +41,9 @@ module Kward
       end
     end
 
+    # Registered lifecycle hook handler.
+    HookHandler = Struct.new(:event, :id, :description, :path, :order, :match, :failure_policy, :handler, keyword_init: true)
+
     # Read-only transcript view exposed to plugin code.
     class Transcript
       # Creates an object for trusted plugin loading and dispatch.
@@ -50,7 +55,7 @@ module Kward
       #
       # @return [Array<Hash>] immutable transcript message data
       def messages
-        PluginRegistry.deep_freeze(PluginRegistry.deep_dup(@conversation.messages))
+        DeepCopy.freeze(DeepCopy.dup(@conversation.messages))
       end
     end
 
@@ -102,6 +107,34 @@ module Kward
         @conversation.refresh_system_message! if @conversation.respond_to?(:refresh_system_message!)
         nil
       end
+
+      def allow(message = nil, metadata: nil)
+        Hooks::Decision.allow(message, metadata: metadata)
+      end
+
+      def deny(message = nil, metadata: nil)
+        Hooks::Decision.deny(message, metadata: metadata)
+      end
+
+      def ask(message = nil, metadata: nil)
+        Hooks::Decision.ask(message, metadata: metadata)
+      end
+
+      def modify(payload, message: nil, metadata: nil)
+        Hooks::Decision.modify(payload, message: message, metadata: metadata)
+      end
+
+      def warn(message = nil, metadata: nil)
+        Hooks::Decision.warn(message, metadata: metadata)
+      end
+
+      def retry(message = nil, payload: nil, metadata: nil)
+        Hooks::Decision.retry(message, payload: payload, metadata: metadata)
+      end
+
+      def defer(message = nil, payload: nil, metadata: nil)
+        Hooks::Decision.defer(message, payload: payload, metadata: metadata)
+      end
     end
 
     # Public DSL object yielded by `Kward.plugin` blocks.
@@ -165,6 +198,25 @@ module Kward
         @registry.register_transcript_event(path: @path, &block)
       end
 
+      # Registers a lifecycle hook handler.
+      #
+      # Hooks are deterministic runtime callbacks around Kward lifecycle events.
+      # They can return a {Hooks::Decision}, a decision hash, a decision string,
+      # or nil to allow the operation.
+      #
+      # @param event [String, #to_s] lifecycle event name
+      # @param id [String, nil] stable hook identifier for logs and diagnostics
+      # @param description [String] short human-readable purpose
+      # @param order [Integer] lower values run first
+      # @param match [Hash, nil] optional event selector
+      # @yieldparam event [Hooks::Event] immutable lifecycle event
+      # @yieldparam ctx [Context] plugin execution context and decision helpers
+      # @return [void]
+      # @api public
+      def hook(event, id: nil, description: "", order: 100, match: nil, failure_policy: nil, &block)
+        @registry.register_hook(event, id: id, description: description, order: order, match: match, failure_policy: failure_policy, path: @path, &block)
+      end
+
       # Registers prompt context text injected into future system prompts.
       #
       # Keep this text short and never include secrets. The returned string can
@@ -205,29 +257,6 @@ module Kward
         paths.each { |path| registry.load_file(path) }
         registry
       end
-
-      def deep_dup(value)
-        case value
-        when Hash
-          value.each_with_object({}) { |(key, item), result| result[key] = deep_dup(item) }
-        when Array
-          value.map { |item| deep_dup(item) }
-        else
-          value.dup
-        end
-      rescue TypeError
-        value
-      end
-
-      def deep_freeze(value)
-        case value
-        when Hash
-          value.each_value { |item| deep_freeze(item) }
-        when Array
-          value.each { |item| deep_freeze(item) }
-        end
-        value.freeze
-      end
     end
 
     # Creates an object for trusted plugin loading and dispatch.
@@ -239,6 +268,7 @@ module Kward
       @footer_path = nil
       @transcript_event_handlers = []
       @prompt_context_renderers = []
+      @hook_handlers = []
       @paths = []
     end
 
@@ -276,6 +306,20 @@ module Kward
       @prompt_context_renderers.map { |entry| entry[:renderer] }
     end
 
+    def hook_handlers
+      @hook_handlers.dup
+    end
+
+    def hook_manager
+      manager = Hooks::Manager.new
+      @hook_handlers.each do |hook|
+        manager.register(hook.event, id: hook.id, source: hook.path, order: hook.order, match: hook.match, failure_policy: hook.failure_policy) do |event, context|
+          hook.handler.call(event, context)
+        end
+      end
+      manager
+    end
+
     def prompt_context(context)
       parts = []
       @prompt_context_renderers.each do |entry|
@@ -387,6 +431,23 @@ module Kward
       @prompt_context_renderers << { path: path, renderer: renderer }
     end
 
+    def register_hook(event, id: nil, description: "", order: 100, match: nil, failure_policy: nil, path: nil, &handler)
+      event = event.to_s
+      raise "Plugin hook event is required" if event.empty?
+      raise "Plugin hook #{event} requires a handler" unless handler
+
+      @hook_handlers << HookHandler.new(
+        event: event,
+        id: id&.to_s || "#{File.basename(path.to_s.empty? ? "plugin" : path)}:#{event}:#{@hook_handlers.length + 1}",
+        description: description.to_s,
+        path: path,
+        order: order.to_i,
+        match: match,
+        failure_policy: failure_policy,
+        handler: handler
+      )
+    end
+
     private
 
     def transcript_event_for(event)
@@ -422,7 +483,7 @@ module Kward
     def transcript_event(type, payload)
       TranscriptEvent.new(
         type: type,
-        payload: PluginRegistry.deep_freeze(PluginRegistry.deep_dup(payload))
+        payload: DeepCopy.freeze(DeepCopy.dup(payload))
       ).freeze
     end
   end

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

@@ -112,7 +112,9 @@ module Kward
       end
 
       def open_diff_viewer(path, content)
-        @editor_state = EditorState.new(path: path.to_s, content: content.to_s, new_file: true, editor_mode: current_editor_mode, readonly: true, diff_view: true)
+        diff_view_mode = current_diff_view_mode
+        viewer_content = diff_view_mode == DiffViewMode::SIDE_BY_SIDE ? side_by_side_diff_content(content.to_s) : content.to_s
+        @editor_state = EditorState.new(path: path.to_s, content: viewer_content, new_file: true, editor_mode: current_editor_mode, readonly: true, diff_view: diff_view_mode)
         @prompt_label = "Diff>"
         self.composer_input = ""
         self.composer_cursor = 0
@@ -131,6 +133,63 @@ module Kward
         @editor_mode
       end
 
+      def current_diff_view_mode
+        configured = @diff_view_source.respond_to?(:call) ? @diff_view_source.call : @diff_view
+        DiffViewMode.resolve(configured, terminal_width: screen_width)
+      rescue StandardError
+        DiffViewMode.resolve(@diff_view, terminal_width: screen_width)
+      end
+
+      def side_by_side_diff_content(content)
+        width = side_by_side_diff_column_width
+        rows = []
+        pending_deletions = []
+
+        content.to_s.each_line(chomp: true) do |line|
+          if side_by_side_diff_metadata_line?(line)
+            rows.concat(flush_side_by_side_deletions(pending_deletions, width))
+            rows << line
+          elsif line.start_with?("-")
+            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)
+          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)
+          end
+        end
+
+        rows.concat(flush_side_by_side_deletions(pending_deletions, width))
+        rows.join("\n")
+      end
+
+      def side_by_side_diff_metadata_line?(line)
+        line.start_with?("diff --git", "index ", "---", "+++", "@@")
+      end
+
+      def flush_side_by_side_deletions(lines, width)
+        lines.shift(lines.length).map { |line| side_by_side_diff_row("- #{line}", nil, width) }
+      end
+
+      def side_by_side_diff_row(left, right, width)
+        left_text = side_by_side_diff_cell(left, width)
+        right_text = side_by_side_diff_cell(right, width)
+        "#{left_text.ljust(width)} │ #{right_text}"
+      end
+
+      def side_by_side_diff_cell(text, width)
+        value = text.nil? ? "" : text.to_s
+        visible_truncate(value, width)
+      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
+        [[(content_width - gutter_width - 3) / 2, 10].max, 80].min
+      end
+
       def current_editor_soft_wrap?
         return @editor_soft_wrap_source.call != false if @editor_soft_wrap_source.respond_to?(:call)
 

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

@@ -174,6 +174,7 @@ module Kward
 
       def editor_render_diff_line(line)
         text = line.to_s
+        return editor_render_side_by_side_diff_line(text) if @editor_state.side_by_side_diff_view?
         return colored(text, :green) if text.start_with?("+") && !text.start_with?("+++")
         return colored(text, :red) if text.start_with?("-") && !text.start_with?("---")
         return colored(text, :cyan) if text.start_with?("@@")
@@ -181,6 +182,16 @@ module Kward
         text
       end
 
+      def editor_render_side_by_side_diff_line(text)
+        return colored(text, :cyan) if text.start_with?("@@")
+        return text unless text.include?(" │ ")
+
+        left, right = text.split(" │ ", 2)
+        rendered_left = left.start_with?("-") ? colored(left, :red) : left
+        rendered_right = right.start_with?("+") ? colored(right, :green) : right
+        "#{rendered_left} │ #{rendered_right}"
+      end
+
       def editor_line_number_gutter_width
         [[@editor_state.lines.length.to_s.length, 4].max + 3, 1].max
       end

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

@@ -373,7 +373,11 @@ module Kward
       end
 
       def diff_view?
-        @diff_view == true
+        !@diff_view.nil? && @diff_view != false
+      end
+
+      def side_by_side_diff_view?
+        @diff_view == DiffViewMode::SIDE_BY_SIDE
       end
 
       def modern?