canopus 0.4.0 → 0.5.0

data/lib/canopus/workspace.rb

@@ -2,27 +2,47 @@
 
 require "json"
 require "fileutils"
+require "shellwords"
+sadr_path = ENV["SADR_PATH"]
+sadr_root = File.expand_path("../..", __dir__)
+sadr_path ? require(File.expand_path("lib/sadr", File.expand_path(sadr_path, sadr_root))) : require("sadr")
 require_relative "settings"
 require_relative "theme"
 require_relative "vim"
-require_relative "lsp"
 require_relative "pane"
 require_relative "project/tree"
 require_relative "command"
 require_relative "panel"
 require_relative "decoration"
+require_relative "provider"
+require_relative "minimap"
+require_relative "diagnostics"
 
 module Canopus
   class Workspace
     ClosedTab = Data.define(:path, :selections, :scroll_x, :scroll_y, :pane_id, :index)
-    attr_reader :panes, :active_pane, :buffers, :actions, :commands, :settings, :theme, :project, :clients, :root, :docks, :panels, :decorations
-    attr_reader :terminals, :active_terminal_index
+    LANGUAGE_SERVER_CAPABILITIES = {
+      "completion" => "completionProvider", "diagnostics" => nil, "codeAction" => "codeActionProvider",
+      "formatting" => "documentFormattingProvider", "definition" => "definitionProvider",
+      "typeDefinition" => "typeDefinitionProvider", "implementation" => "implementationProvider",
+      "hover" => "hoverProvider", "signatureHelp" => "signatureHelpProvider", "references" => "referencesProvider",
+      "rename" => "renameProvider", "documentSymbol" => "documentSymbolProvider", "codeLens" => "codeLensProvider",
+      "inlayHint" => "inlayHintProvider", "semanticTokens" => "semanticTokensProvider",
+      "documentHighlight" => "documentHighlightProvider", "foldingRange" => "foldingRangeProvider",
+      "selectionRange" => "selectionRangeProvider", "callHierarchy" => "callHierarchyProvider",
+      "typeHierarchy" => "typeHierarchyProvider", "documentLink" => "documentLinkProvider",
+      "linkedEditingRange" => "linkedEditingRangeProvider", "workspaceSymbol" => "workspaceSymbolProvider"
+    }.freeze
+    attr_reader :panes, :active_pane, :buffers, :actions, :commands, :settings, :theme, :project, :clients, :root, :docks, :panels, :decorations, :providers, :minimap, :diagnostics, :breakpoints, :trust
+    attr_reader :terminals, :active_terminal_index, :terminal_layout
     attr_accessor :window, :terminal_composition, :selected_project_path, :performance
     attr_reader :message, :palette
 
     def initialize(root: Dir.pwd, settings: nil)
       @root = File.realpath(root)
+      @trust = Trust.new(@root)
       @settings = settings || Settings.new(Settings.user_path, File.join(@root, ".canopus", "settings.jsonc"))
+      @main_queue = Queue.new
       @panes, @buffers = [Pane.new], {}
       @active_pane = @panes.first
       @layout = {pane: @active_pane}
@@ -41,6 +61,14 @@ module Canopus
       @panels.register(Panel::Definition.new("terminal", "Terminal", nil, :bottom, -> { terminal }, nil))
       @panels.register(Panel::Definition.new("search", "Search", nil, :left, -> { palette_open(:project_search) }, nil))
       @panels.register(Panel::Definition.new("explorer", "Explorer", nil, :left, -> { project_tree }, nil))
+      @panels.register(Panel::Definition.new("scm", "Source Control", nil, :left, -> { scm_panel }, nil), visible: false)
+      @panels.register(Panel::Definition.new("hierarchy", "Hierarchy", nil, :right, -> { hierarchy_tree }, nil), visible: false)
+      @panels.register(Panel::Definition.new("problems", "Problems", nil, :right, -> { problems_tree }, nil), visible: false)
+      @panels.register(Panel::Definition.new("debug", "Debug", nil, :left, -> { debug_tree }, nil), visible: false)
+      @panels.register(Panel::Definition.new("debug_console", "Debug Console", nil, :bottom, -> { debug_console_tree }, nil), visible: false)
+      @panels.register(Panel::Definition.new("output", "Output", nil, :bottom, -> { task_output }, nil), visible: false)
+      @panels.register(Panel::Definition.new("test", "Tests", nil, :left, -> { test_tree }, nil), visible: false)
+      @panels.hide("hierarchy")
       @decorations = Decoration::Registry.new
       @decorations.register(:selection_match) do |buffer, rows, current|
         selections = current.is_a?(Editor) && current.buffer.equal?(buffer) ? current.selections : buffer.selections
@@ -54,9 +82,30 @@ module Canopus
         end
       end
       @decorations.register(:git) { |buffer, rows| git_decorations(buffer, rows) }
+      @decorations.register(:scm_diff) { |buffer, rows| scm_diff_decorations(buffer, rows) }
+      @decorations.register(:merge_conflict) { |buffer, rows| git_conflict_decorations(buffer, rows) }
+      @decorations.register(:blame) { |buffer, rows, current| git_blame_decorations(buffer, rows, current) }
+      @decorations.register(:diagnostics) { |buffer, rows| diagnostic_decorations(buffer, rows) }
+      @decorations.register(:document_highlight) { |buffer, rows, current| document_highlight_decorations(buffer, rows, current) }
+      @decorations.register(:document_link) { |buffer, rows, current| document_link_decorations(buffer, rows, current) }
+      @decorations.register(:inlay_hint) { |buffer, rows| inlay_hint_decorations(buffer, rows) }
+      @decorations.register(:code_lens) { |buffer, rows| code_lens_decorations(buffer, rows) }
+      @decorations.register(:bracket) { |buffer, rows, current| bracket_decorations(buffer, rows, current) }
+      initialize_breakpoints
+      @minimap = Minimap.new
+      @diagnostics = Diagnostics::Registry.new do |uri|
+        @window ? post { diagnostics_changed(uri) } : diagnostics_changed(uri)
+      end
+      publish_settings_diagnostics(@settings.paths)
+      @providers = Provider::Registry.new
+      @providers.register_completion(:lsp, priority: 100) { |buffer, offset, context| lsp_completions(buffer, offset, context) }
       @languages, @terminals = {}, []
       @active_terminal_index = 0
+      @terminal_layout = nil
       @closed_tabs, @terminal_names = [], {}
+      @terminal_profiles = {}.compare_by_identity
+      initialize_tasks
+      initialize_tests
       register_actions
     end
     def editor = @active_pane.active
@@ -66,7 +115,12 @@ module Canopus
     end
     def terminal_visible = @panels.visible?("terminal") && @docks[:bottom][:visible]
     def terminal_visible=(visible)
-      visible ? @panels.show("terminal") : @panels.hide("terminal")
+      if visible
+        @panels.hide("output") if @panels.visible?("output")
+        @panels.show("terminal")
+      else
+        @panels.hide("terminal")
+      end
     end
     def terminal = @terminals[@active_terminal_index]
     def terminal=(value)
@@ -76,10 +130,20 @@ module Canopus
       @terminal_resize_times&.clear
       @terminals = value ? [value] : []
       @active_terminal_index = 0
+      @terminal_layout = value ? {terminal: value} : nil
+      @terminal_profiles.clear
       value
     end
     def palette=(value)
+      @palette_generation = @palette_generation.to_i + 1
+      if @workspace_symbol_request && value&.dig(:workspace_symbol_generation) != @workspace_symbol_generation
+        cancel_workspace_symbol_search
+      end
       previous, @palette = @palette, @closed ? nil : value
+      rename = previous&.dig(:kind) == :rename && previous[:rename]
+      if rename && !previous.equal?(@submitting_rename_palette) && !rename.equal?(@palette&.dig(:rename))
+        release_rename_snapshot(rename)
+      end
       response = previous&.dig(:response)
       unless response.nil? || response.equal?(@palette&.dig(:response))
         response.fulfill({"applied" => false, "failureReason" => value ? "Replaced by another dialog" : "User cancelled"})
@@ -117,6 +181,7 @@ module Canopus
     def refresh_files
       @files = @project_tree = @project_entries = nil
       @finder_index = nil
+      refresh_tests if @test_discovery_started && !@closed
       if @palette && @palette[:kind] == :files
         @palette.delete(:search)
         update_palette
@@ -126,9 +191,16 @@ module Canopus
     def vim = @vim_states[editor] ||= Vim.new(editor).tap { |state| state.on_command = ->(command) { ex_command(command) } }
     def open(path)
       absolute = canonical_path(path)
-      buffer = @buffers[absolute] ||= File.file?(absolute) ? Buffer.open(absolute) : Buffer.new("", path: absolute)
+      buffer = @buffers[absolute]
+      unless buffer
+        buffer = File.file?(absolute) ? Buffer.open(absolute) : Buffer.new("", path: absolute)
+        @buffers[absolute] = buffer
+        mark_persistent_undo_path(buffer, path)
+        load_persistent_undo(buffer)
+      end
       @vim_states[editor]&.deactivate unless editor&.buffer.equal?(buffer)
       opened = @active_pane.open(buffer)
+      attach_breakpoints(buffer)
       @recent_files ||= []
       @recent_files.delete(absolute)
       @recent_files.unshift(absolute)
@@ -137,6 +209,7 @@ module Canopus
       opened.language = definition_for(absolute)
       apply_editor_settings(opened)
       @project_tree&.reveal(absolute.delete_prefix(@root + File::SEPARATOR))
+      invalidate_hidden_selection_ranges
       @window&.request_frame
       opened
     end
@@ -150,25 +223,46 @@ module Canopus
       end
       File.join(File.realpath(parent), *pieces)
     end
-    def save_buffer(buffer = editor.buffer, path: buffer.path)
+    def save_buffer(buffer = editor.buffer, path: buffer.path, encoding: nil, confirmed: false)
       if buffer.is_a?(MultiBuffer)
-        buffer.excerpts.map(&:buffer).uniq.each { |source| save_buffer(source) if source.dirty? }
+        buffer.excerpts.map(&:buffer).uniq.each { |source| save_buffer(source, encoding: encoding) if source.dirty? }
         return buffer
       end
       target = path && canonical_path(path)
       raise Error, "Choose a path before saving" unless target
       existing = @buffers[target]
       raise Error, "Destination is already open in another buffer" if existing && !existing.equal?(buffer)
+      unless confirmed || buffer.roundtrip?(encoding: encoding)
+        self.palette = {kind: :confirm_encoding_save, query: "Encoding cannot represent all characters. Save anyway?",
+          index: 1, matches: ["Save anyway", "Cancel"], buffer: buffer, target: target, encoding: encoding}
+        return buffer
+      end
       previous = buffer.path
-      result = buffer.save(target)
+      prepare_editorconfig_save(buffer, target)
+      @running_save_actions ||= {}.compare_by_identity
+      unless @running_save_actions.key?(buffer)
+        @running_save_actions[buffer] = true
+        begin
+          run_save_actions(buffer) if previous
+        rescue StandardError => error
+          notify("Save actions failed: #{error.message}")
+        ensure
+          @running_save_actions.delete(buffer)
+        end
+      end
+      result = buffer.save(target, encoding: encoding)
       if previous != buffer.path
+        relocate_breakpoints(buffer)
+        invalidate_hierarchy(buffer)
+        invalidate_prepare_rename(buffer)
+        invalidate_document_links(buffer)
+        invalidate_linked_editing_ranges(buffer)
         invalidate_git
         # Close the old URI before registering this buffer under its new path.
         @opened_lsp_documents&.keys&.each do |client, document|
           next unless document.equal?(buffer)
-          @opened_lsp_documents.delete([client, document])
           begin
-            client.close_document(LSP::Protocol.uri(previous)) if previous
+            close_language_document(client, document, uri: Sadr::Protocol.uri(previous)) if previous
           rescue StandardError => error
             @message = "File saved; language server close failed: #{error.message}"
           end
@@ -187,19 +281,48 @@ module Canopus
       @opened_lsp_documents&.each_key do |client, document|
         next unless document.equal?(buffer)
         begin
-          client.save_document(LSP::Protocol.uri(buffer.path))
+          client.save(Sadr::Protocol.uri(buffer.path))
         rescue StandardError => error
           self.message = "File saved; language server notification failed: #{error.message}"
         end
       end
       result
     end
+
+    def show_encoding_actions(buffer = editor&.buffer)
+      return unless buffer&.path && !buffer.read_only
+
+      choices = [Encoding::UTF_8, Encoding::UTF_16LE, Encoding::UTF_16BE, Encoding::UTF_32LE, Encoding::UTF_32BE,
+        Encoding::Windows_31J,
+        Encoding::EUC_JP, Encoding::ISO_2022_JP].uniq
+      actions = choices.flat_map do |encoding|
+        [["Reload as #{encoding.name}", :reload, encoding], ["Save as #{encoding.name}", :save, encoding]]
+      end
+      self.palette = {kind: :encoding_actions, query: +"", index: 0, matches: actions.map(&:first),
+        encoding_actions: actions, buffer: buffer}
+      @palette
+    end
+
+    def convert_line_endings(to, confirmed: false)
+      buffer = editor&.buffer
+      return unless buffer && !buffer.read_only
+      if buffer.mixed_line_endings? && !confirmed
+        self.palette = {kind: :confirm_line_ending_conversion,
+          query: "Mixed line endings will be normalized. Continue?", index: 1,
+          matches: ["Convert line endings", "Cancel"], buffer: buffer, to: to}
+        return buffer
+      end
+
+      buffer.convert_line_endings(to: to)
+      self.message = "Line endings converted to #{to.to_s.upcase}"
+    end
     def new_buffer
       @vim_states[editor]&.deactivate
       buffer = Buffer.new
       @buffers[buffer.object_id] = buffer
       opened = @active_pane.open(buffer)
       apply_editor_settings(opened)
+      invalidate_hidden_selection_ranges
       opened
     end
     def focus(pane)
@@ -213,6 +336,7 @@ module Canopus
       @vim_states[editor]&.deactivate unless tab.equal?(editor)
       focus(pane)
       pane.activate(pane.editors.index(tab))
+      invalidate_hidden_selection_ranges
     end
     def split(direction = :horizontal)
       raise ArgumentError, "invalid split" unless [:horizontal, :vertical].include?(direction)
@@ -245,6 +369,16 @@ module Canopus
       end
       sources = current.buffer.is_a?(MultiBuffer) ? current.buffer.excerpts.map(&:buffer).uniq : []
       @vim_states.delete(current)&.dispose
+      @sticky_fallback_cache&.delete(current)
+      @sticky_context_cache&.clear
+      invalidate_document_highlights(editor: current)
+      invalidate_folding_ranges(editor: current)
+      invalidate_selection_ranges(editor: current)
+      invalidate_hierarchy(editor: current)
+      invalidate_prepare_rename(editor: current)
+      invalidate_document_links(editor: current)
+      invalidate_linked_editing_ranges(editor: current)
+      invalidate_brackets(current.buffer)
       pane.close(current, discard: discard, activate: @settings["tabs"]["activate_on_close"].to_sym)
       release_buffer(current.buffer, discard: discard)
       sources.each { |source| release_buffer(source, discard: discard) }
@@ -329,25 +463,63 @@ module Canopus
       to.active_index = index
       to.pin(editor) if pinned
       focus(to)
+      invalidate_hidden_selection_ranges
+    end
+
+    def new_terminal(cwd: nil, profile: nil)
+      previous = terminal
+      created = start_terminal(cwd: cwd, profile: profile)
+      @terminal_layout = replace_terminal_leaf(@terminal_layout, previous, created) || {terminal: created}
+      invalidate_terminal_layout_resize
+      created
+    end
+
+    def split_terminal(direction, profile: nil)
+      raise ArgumentError, "invalid terminal split direction" unless %i[horizontal vertical].include?(direction)
+      previous = terminal
+      return new_terminal(profile: profile) unless previous
+      created = start_terminal(cwd: terminal_cwd(previous), profile: profile)
+      split = {direction: direction, ratio: 0.5, children: [{terminal: previous}, {terminal: created}]}
+      @terminal_layout = replace_terminal_node(@terminal_layout, previous, split) || split
+      invalidate_terminal_layout_resize
+      created
     end
 
-    def new_terminal(cwd: terminal_working_directory)
+    def terminal_profile(current = terminal) = @terminal_profiles[current]
+
+    def start_terminal(cwd: nil, profile: nil)
       options = @settings["terminal"]
-      created = Terminal::PTY.new(command: options["shell"] || ENV.fetch("SHELL", "/bin/sh"), cwd: cwd,
-        columns: 100, rows: 12, env: options["env"], scrollback: options["scrollback_lines"],
+      cwd ||= terminal&.respond_to?(:cwd) && terminal.cwd
+      cwd = terminal_working_directory unless cwd && File.directory?(cwd)
+      profile ||= options["default_profile"]
+      configured = profile && options["profiles"].fetch(profile)
+      fallback = Gem.win_platform? ? ENV.fetch("COMSPEC", "cmd.exe") : ENV.fetch("SHELL", "/bin/sh")
+      command = configured && terminal_profile_command(configured) || options["shell"] || fallback
+      env = options["env"].merge(configured&.fetch("env", {}) || {})
+        .merge("CANOPUS" => "1", "EDITOR" => "canopus --wait")
+      created = Tarazed::Session.new(command: command, cwd: cwd,
+        columns: 100, rows: 12, env: env, scrollback_limit: options["scrollback_lines"],
         queue_limit_bytes: options["queue_limit_bytes"])
+      inject_shell_integration(created) if options["shell_integration"]
       @terminals << created
+      @terminal_profiles[created] = profile if profile
       @active_terminal_index = @terminals.length - 1
       self.terminal_visible = true
-      resize_terminal(*@terminal_dimensions, final: true) if @terminal_dimensions
+      resize_terminal(*@terminal_dimensions, final: true, terminal: created) if @terminal_dimensions
       @window&.request_frame
       created
     end
+    private :start_terminal
 
     def activate_terminal(index)
       raise IndexError, "terminal tab outside panel" unless index.is_a?(Integer) && index.between?(0, @terminals.length - 1)
+      previous = terminal
       @active_terminal_index = index
-      resize_terminal(*@terminal_dimensions, final: true) if @terminal_dimensions
+      unless terminal_layout_include?(terminal)
+        @terminal_layout = replace_terminal_leaf(@terminal_layout, previous, terminal)
+        invalidate_terminal_layout_resize
+      end
+      @terminal_layout ||= {terminal: terminal}
       @window&.request_frame
       terminal
     end
@@ -376,14 +548,26 @@ module Canopus
       current = @terminals.delete_at(index)
       return unless current
       @terminal_names.delete(current)
+      @terminal_profiles.delete(current)
       @terminal_sizes&.delete(current)
+      @terminal_dimensions_by_terminal&.delete(current)
       @terminal_resize_times&.delete(current)
       current.close if current.respond_to?(:close)
+      visible = terminal_layout_include?(current)
+      @terminal_layout = remove_terminal_leaf(@terminal_layout, current) if visible
       @active_terminal_index = if current.equal?(active)
         [index, @terminals.length - 1].min.clamp(0, @terminals.length)
       else
         @terminals.index(active) || 0
       end
+      if @terminals.empty?
+        @terminal_layout = nil
+      elsif visible
+        replacement = terminal_layout_terminals.first || terminal
+        @active_terminal_index = @terminals.index(replacement) || @active_terminal_index
+        @terminal_layout ||= {terminal: terminal}
+        invalidate_terminal_layout_resize
+      end
       self.terminal_visible = false if @terminals.empty? && @settings["terminal"]["hide_when_empty"]
       @window&.request_frame
       current
@@ -392,19 +576,30 @@ module Canopus
     def restart_terminal(index = @active_terminal_index)
       current = @terminals[index]
       return unless current
-      cwd = current.vt.cwd || (current.respond_to?(:initial_cwd) ? current.initial_cwd : @root)
+      cwd = terminal_cwd(current)
       name = @terminal_names[current]
-      close_terminal(index)
-      replacement = new_terminal(cwd: File.directory?(cwd) ? cwd : @root)
-      move_terminal(@terminals.length - 1, index) if index < @terminals.length - 1
+      profile = @terminal_profiles[current]
+      replacement = start_terminal(cwd: File.directory?(cwd) ? cwd : @root, profile: profile)
+      @terminals.delete(replacement)
+      @terminals[index] = replacement
+      @active_terminal_index = index
+      @terminal_layout = replace_terminal_leaf(@terminal_layout, current, replacement)
+      invalidate_terminal_layout_resize
+      @terminal_names.delete(current)
+      @terminal_profiles.delete(current)
+      @terminal_sizes&.delete(current)
+      @terminal_dimensions_by_terminal&.delete(current)
+      @terminal_resize_times&.delete(current)
+      current.close if current.respond_to?(:close)
       rename_terminal(name, replacement) if name
       replacement
     end
 
     def terminal_title(current = terminal)
       return "Terminal" unless current
+      cwd = current.respond_to?(:cwd) ? current.cwd : current.vt.cwd
       title = @terminal_names[current] || current.vt.title.to_s.then { |value| value.empty? ? nil : value } ||
-        current.vt.cwd&.then { |cwd| File.basename(cwd).empty? ? cwd : File.basename(cwd) } ||
+        cwd&.then { |path| File.basename(path).empty? ? path : File.basename(path) } ||
         (current.respond_to?(:foreground_process_name) ? current.foreground_process_name : nil) ||
         (current.respond_to?(:command_name) ? current.command_name : nil) || "shell"
       title.to_s.encode(Encoding::UTF_8, invalid: :replace, undef: :replace).scrub.slice(0, 200)
@@ -416,6 +611,14 @@ module Canopus
       value.empty? ? @terminal_names.delete(current) : @terminal_names[current] = value.slice(0, 200)
     end
 
+    def show_terminal_commands(failed: false)
+      items = retained_terminal_commands
+      items = items.select { |command| command.exit_status && command.exit_status != 0 } if failed
+      self.palette = {kind: :terminal_commands, query: +"", index: 0, items: items,
+        matches: items.map { |command| terminal_command_label(command) }}
+      update_palette
+    end
+
     def drain_terminals(now: Process.clock_gettime(Process::CLOCK_MONOTONIC))
       return false if @terminals.empty?
       remaining = @settings["terminal"]["max_bytes_per_frame"]
@@ -436,15 +639,17 @@ module Canopus
       changed
     end
 
-    def resize_terminal(columns, rows, final: false, now: Process.clock_gettime(Process::CLOCK_MONOTONIC))
+    def resize_terminal(columns, rows, final: false, now: Process.clock_gettime(Process::CLOCK_MONOTONIC), terminal: nil)
       minimum = @settings["terminal"]
       dimensions = [[columns.to_i, minimum["min_cols"]].max, [rows.to_i, minimum["min_rows"]].max]
-      @terminal_dimensions = dimensions
+      @terminal_dimensions = dimensions if !terminal || terminal.equal?(self.terminal)
       return if @terminals.empty?
       final ||= @terminal_resize_final
       @terminal_resize_final = false
       wait = minimum["resize_debounce_ms"] / 1000.0
-      @terminals.each do |current|
+      targets = terminal ? [terminal] : @terminals
+      targets.each do |current|
+        (@terminal_dimensions_by_terminal ||= {})[current] = dimensions
         previous = (@terminal_resize_times ||= {})[current]
         next if !final && previous && now - previous < wait
         next if (@terminal_sizes ||= {})[current] == dimensions
@@ -455,7 +660,13 @@ module Canopus
     end
 
     def flush_terminal_resize
-      resize_terminal(*@terminal_dimensions, final: true) if @terminal_dimensions
+      if @terminal_dimensions_by_terminal&.any?
+        @terminal_dimensions_by_terminal.dup.each do |current, dimensions|
+          resize_terminal(*dimensions, final: true, terminal: current) if @terminals.include?(current)
+        end
+      elsif @terminal_dimensions
+        resize_terminal(*@terminal_dimensions, final: true)
+      end
       @terminal_resize_final = true
     end
 
@@ -484,8 +695,8 @@ module Canopus
         end
       end
     end
-    def command_context(terminal: false)
-      {"Terminal" => terminal, "Editor" => !!editor,
+    def command_context(terminal: false, task_output: false)
+      {"Terminal" => terminal, "TaskOutput" => task_output, "Editor" => !!editor,
        "vim_mode" => @settings["vim_mode"] && editor ? vim.mode.to_s : false}
     end
     def call(name, *args, context: nil)
@@ -514,6 +725,8 @@ module Canopus
         @palette[:search_options] = {regexp: false, case_sensitive: true, whole_word: false, selection_only: false}
         @palette[:selection] = editor.primary.range unless editor.primary.empty?
         @palette[:editor], @palette[:version] = editor, editor.buffer.version
+      elsif kind == :regex_matches
+        @palette[:editor], @palette[:version] = editor, editor.buffer.version
       end
       update_palette
     end
@@ -538,9 +751,76 @@ module Canopus
         @palette[:index] = @palette[:index].clamp(0, [@palette[:matches].length - 1, 0].max)
         return
       end
-      if [:completion, :locations, :symbols, :code_actions, :outline, :branches, :settings_keys, :snippet_choices].include?(@palette[:kind])
+      if @palette[:kind] == :completion
+        labels = @palette[:all_matches] ||= @palette[:matches].dup
+        candidates = @palette[:items].map do |item|
+          item.is_a?(Provider::Completion) ? item.filter_text || item.label : item["filterText"] || item.fetch("label")
+        end
+        groups = @palette[:completion_indices] ||= candidates.each_with_index.each_with_object({}) do |(candidate, index), grouped|
+          (grouped[candidate] ||= []) << index
+        end
+        session = @palette[:search] ||= Spica::Index.new(groups.keys, tie_break: :index).session
+        session.query = @palette[:query]
+        matches = session.matches(12)
+        @palette[:indices] = matches.flat_map { |match| groups.fetch(match.candidate) }.first(12)
+        @palette[:matches] = @palette[:indices].map { |index| labels.fetch(index) }
+        @palette[:index] = 0
+        return
+      end
+      if @palette[:kind] == :workspace_symbol_results
+        labels = @palette.fetch(:all_matches)
+        if @palette[:query].empty?
+          @palette[:indices] = (0...[labels.length, 12].min).to_a
+          @palette[:matches] = @palette[:indices].map { |index| labels.fetch(index) }
+        else
+          session = @palette[:search] ||= @palette.fetch(:workspace_symbol_index).session
+          session.query = @palette[:query]
+          groups = @palette.fetch(:workspace_symbol_groups)
+          @palette[:indices] = session.matches(12).flat_map { |match| groups.fetch(match.candidate) }.first(12)
+          @palette[:matches] = @palette[:indices].map { |index| labels.fetch(index) }
+        end
+        @palette[:index] = 0
+        return
+      end
+      if @palette[:kind] == :git_commit_history
+        labels = @palette[:all_matches] ||= @palette[:matches].dup
+        groups = @palette[:history_search_groups] ||= @palette.fetch(:search_values).each_with_index.each_with_object({}) do |(value, index), result|
+          (result[value] ||= []) << index
+        end
+        session = @palette[:search] ||= Spica::Index.new(groups.keys, tie_break: :index).session
+        session.query = @palette[:query]
+        @palette[:indices] = session.matches(12).flat_map { |match| groups.fetch(match.candidate) }.first(12)
+        @palette[:matches] = @palette[:indices].map { |index| labels.fetch(index) }
+        @palette[:index] = 0
+        return
+      end
+      if @palette[:kind] == :terminal_commands
         labels = @palette[:all_matches] ||= @palette[:matches].dup
-        session = @palette[:search] ||= Spica::Index.new(labels).session
+        groups = @palette[:terminal_command_groups] ||= labels.each_with_index.each_with_object({}) do |(label, index), result|
+          (result[label] ||= []) << index
+        end
+        session = @palette[:search] ||= Spica::Index.new(groups.keys).session
+        session.query = @palette[:query]
+        @palette[:indices] = session.matches(12).flat_map { |match| groups.fetch(match.candidate) }.first(12)
+        @palette[:matches] = @palette[:indices].map { |index| labels.fetch(index) }
+        @palette[:index] = 0
+        return
+      end
+      if @palette[:kind] == :settings_edit
+        @palette[:index] = @palette[:index].clamp(0, @palette[:matches].length - 1)
+        return
+      end
+      if @palette[:kind] == :keymap_edit
+        @palette[:index] = @palette[:index].clamp(0, @palette[:matches].length - 1)
+        return
+      end
+      if [:locations, :symbols, :code_actions, :outline, :branches, :settings_keys, :settings_gui, :keymap_gui, :keymap_presets, :snippet_choices,
+          :breadcrumbs, :hierarchy_roots, :language_servers, :debug_configurations, :debug_watch_remove, :tasks,
+          :git_file_history, :git_commit_paths, :git_remotes].include?(@palette[:kind])
+        labels = @palette[:all_matches] ||= @palette[:matches].dup
+        index = [:language_servers, :git_file_history].include?(@palette[:kind]) ?
+          Spica::Index.new(labels, tie_break: :index) : Spica::Index.new(labels)
+        session = @palette[:search] ||= index.session
         session.query = @palette[:query]
         matches = session.matches(12)
         @palette[:indices] = matches.map(&:index)
@@ -561,13 +841,51 @@ module Canopus
       @palette[:index] = @palette[:index].clamp(0, [@palette[:matches].length - 1, 0].max)
     end
     def palette_accept
+      return accept_task_palette if @palette[:kind] == :tasks
+      if @palette[:kind] == :encoding_actions
+        current = @palette
+        action = current[:encoding_actions][current[:index]]
+        self.palette = nil
+        return unless action
+
+        buffer = current[:buffer]
+        return unless @buffers.value?(buffer) || editor&.buffer.equal?(buffer)
+        if action[1] == :reload
+          buffer.reload(force: false, encoding: action[2])
+          self.message = "Reloaded as #{action[2].name}"
+        else
+          save_buffer(buffer, encoding: action[2])
+          self.message = "Saved as #{action[2].name}" unless @palette&.fetch(:kind, nil) == :confirm_encoding_save
+        end
+        return buffer
+      end
+      if @palette[:kind] == :confirm_line_ending_conversion
+        current = @palette
+        self.palette = nil
+        return if current[:index] != 0
+
+        buffer = current[:buffer]
+        return unless @buffers.value?(buffer) || editor&.buffer.equal?(buffer)
+        return convert_line_endings(current[:to], confirmed: true)
+      end
+      if @palette[:kind] == :confirm_encoding_save
+        current = @palette
+        self.palette = nil
+        return if current[:index] != 0
+
+        return save_buffer(current[:buffer], path: current[:target], encoding: current[:encoding], confirmed: true)
+      end
+      return accept_breakpoint_palette if [:breakpoint_actions, :breakpoint_edit].include?(@palette[:kind])
+      return accept_debug_watch_palette if [:debug_watch_add, :debug_watch_remove].include?(@palette[:kind])
+      return accept_debug_console_palette if @palette[:kind] == :debug_console
+      return accept_git_credentials if @palette[:kind] == :git_credentials
       search_state = @palette.slice(:search_options, :selection, :editor, :version)
       after_save = @palette[:after_save]
       if @palette[:kind] == :snippet_choices
         current = @palette
         self.palette = nil
         return @panes.any? { |pane| pane.editors.include?(current[:editor]) } && current[:editor].choose_snippet(current[:matches][current[:index]])
-      elsif [:completion, :locations, :symbols, :code_actions].include?(@palette[:kind])
+      elsif [:completion, :locations, :symbols, :code_actions, :workspace_symbol_results].include?(@palette[:kind])
         current = @palette
         self.palette = nil
         index = current[:indices] ? current[:indices][current[:index]] : current[:index]
@@ -582,6 +900,76 @@ module Canopus
           editor.reveal_cursor
         end
         return
+      elsif @palette[:kind] == :breadcrumbs
+        current = @palette
+        index = current[:indices] ? current[:indices][current[:index]] : current[:index]
+        self.palette = nil
+        return accept_breadcrumb_palette(current, index)
+      elsif @palette[:kind] == :hierarchy_roots
+        current = @palette
+        index = current[:indices] ? current[:indices][current[:index]] : current[:index]
+        self.palette = nil
+        return accept_hierarchy_root(current, index)
+      elsif @palette[:kind] == :language_servers
+        current = @palette
+        index = current[:indices] ? current[:indices][current[:index]] : current[:index]
+        server = index && current[:items][index]
+        self.palette = nil
+        return restart_language_server(server[:language], server[:index]) if server
+      elsif @palette[:kind] == :debug_configurations
+        current = @palette
+        index = current[:indices] ? current[:indices][current[:index]] : current[:index]
+        configuration = index && current[:items][index]
+        self.palette = nil
+        return start_debugging(configuration.fetch("name")) if configuration
+      elsif @palette[:kind] == :terminal_commands
+        current = @palette
+        index = current[:indices] ? current[:indices][current[:index]] : current[:index]
+        self.palette = nil
+        return index && current[:items][index]
+      elsif @palette[:kind] == :problem_filter
+        query = @palette[:query]
+        self.palette = nil
+        return apply_problem_filter(query)
+      elsif @palette[:kind] == :git_file_history
+        current = @palette
+        index = current[:indices] ? current[:indices][current[:index]] : current[:index]
+        entry = index && current[:items][index]
+        self.palette = nil
+        return compare_git_revisions(entry.parent, entry.oid, path: entry.path) if entry
+      elsif @palette[:kind] == :git_commit_history
+        current = @palette
+        index = current[:indices] ? current[:indices][current[:index]] : current[:index]
+        entry = index && current[:items][index]
+        self.palette = nil
+        return open_git_commit(entry) if entry
+      elsif @palette[:kind] == :git_commit_paths
+        current = @palette
+        index = current[:indices] ? current[:indices][current[:index]] : current[:index]
+        path = index && current[:items][index]
+        self.palette = nil
+        commit = current.fetch(:commit)
+        return compare_git_revisions(commit.parents.first, commit.oid, path: path) if path
+      elsif @palette[:kind] == :git_remotes
+        current = @palette
+        index = current[:indices] ? current[:indices][current[:index]] : current[:index]
+        remote = index && current[:items][index]
+        self.palette = nil
+        return public_send(:"#{current.fetch(:operation)}_git", remote) if remote
+      elsif @palette[:kind] == :git_revision_compare
+        current = @palette
+        revisions = current[:query].split("..", -1)
+        self.palette = nil
+        raise Error, "Enter revisions as FROM..TO" unless revisions.length == 2 && revisions.all? { |revision| !revision.empty? }
+        return compare_git_revisions(revisions.first, revisions.last, path: current[:path])
+      elsif @palette[:kind] == :rename && @palette[:rename]
+        current = @submitting_rename_palette = @palette
+        begin
+          self.palette = nil
+        ensure
+          @submitting_rename_palette = nil
+        end
+        return rename_prepared(current[:rename], current[:query])
       end
       selected = @palette[:matches][@palette[:index]]
       selected_command = if @palette[:kind] == :commands && selected
@@ -590,6 +978,7 @@ module Canopus
       end
       command_context = @palette[:command_context]
       kind, query, pattern = @palette.values_at(:kind, :query, :pattern)
+      current = @palette
       self.palette = nil
       if kind == :files && selected
         open(selected)
@@ -598,8 +987,12 @@ module Canopus
       elsif kind == :search
         pattern, options = search_query(query, search_state)
         matches = editor.search(pattern, **options)
+        @minimap.record_search(editor.buffer, editor.buffer.version, matches)
         editor.select(matches.first.begin, matches.first.end) unless matches.empty?
         @message = "#{matches.length} matches"
+      elsif kind == :regex_matches
+        pattern, options = search_query(query, search_state.merge(search_options: {regexp: true}))
+        @message = "#{editor.select_matches(pattern, **options).length} matches"
       elsif kind == :project_search
         search_project(query, **search_state.fetch(:search_options, {}).reject { |key, _| key == :selection_only })
       elsif kind == :replace_query
@@ -628,7 +1021,46 @@ module Canopus
       elsif kind == :branches && selected
         checkout_branch(selected)
       elsif kind == :settings_keys && selected
-        editor.insert_text("#{JSON.generate(selected)}: #{JSON.generate(Settings::DEFAULTS.fetch(selected))}", auto_indent: false)
+        editor.insert_text("#{JSON.generate(selected)}: #{JSON.generate(Settings::DEFAULTS.fetch(selected))}", auto_indent: false, pair: false)
+      elsif kind == :settings_gui && selected
+        index = current[:indices] ? current[:indices][current[:index]] : current[:index]
+        field = current.fetch(:fields).fetch(index)
+        self.palette = {kind: :settings_edit, query: JSON.generate(field[:value]), index: 0,
+          matches: ["Save", "Reset to default"], field: field, settings_file: current.fetch(:settings_file)}
+      elsif kind == :settings_edit
+        field = current.fetch(:field)
+        value = current[:index] == 1 ? field[:default] : JSON.parse(query)
+        begin
+          @settings.set_file(current.fetch(:settings_file), field.fetch(:path), value)
+          self.palette = nil
+          poll_settings(force: true)
+          @message = "Updated #{field[:path].join(".")}"
+        rescue StandardError => error
+          @message = error.message
+          self.palette = current
+        end
+      elsif kind == :keymap_gui && selected
+        index = current[:indices] ? current[:indices][current[:index]] : current[:index]
+        entry = current.fetch(:entries).fetch(index)
+        self.palette = {kind: :keymap_edit, query: entry[:keys].dup, index: 0, matches: ["Save"],
+          entry: entry, settings_file: current.fetch(:settings_file)}
+      elsif kind == :keymap_edit
+        begin
+          apply_keymap_binding(current.fetch(:entry), query)
+          self.palette = nil
+          @message = "Updated #{current[:entry][:id]} key binding"
+        rescue StandardError => error
+          @message = error.message
+          self.palette = current
+        end
+      elsif kind == :keymap_presets && selected
+        begin
+          load_keymap_preset(selected)
+          self.palette = nil
+          @message = "Loaded #{selected} keymap preset"
+        rescue StandardError => error
+          @message = error.message
+        end
       end
     end
     def search_query(query, state)
@@ -645,7 +1077,7 @@ module Canopus
       [pattern, search_options]
     end
     def connect_server(language, command)
-      options = normalize_server_options({"command" => command})
+      options = normalize_server_configuration(command)
       (@client_lock ||= Mutex.new).synchronize { ensure_language_server(language, options) }
     end
     def drain
@@ -663,27 +1095,61 @@ module Canopus
       nil
     end
     def close
+      reset_auto_save
       @closed = true
+      cancel_workspace_symbol_search
+      cancel_completion_requests
       cancel_project_search
+      invalidate_hierarchy
+      invalidate_document_highlights
+      invalidate_folding_ranges
+      invalidate_selection_ranges
+      invalidate_prepare_rename
+      invalidate_document_links
+      invalidate_linked_editing_ranges
+      invalidate_inlay_hints
+      @inlay_hint_requests&.clear
+      invalidate_code_lenses
+      invalidate_sticky_symbols
+      @sticky_symbol_requests&.clear
       @palette&.dig(:response)&.fulfill({"applied" => false, "failureReason" => "Workspace closed"})
       self.palette = nil
       @plugins&.close
-      @watcher&.close
-      stop_language_servers
+      failure = nil
+      cleanup = lambda do |&operation|
+        operation.call
+      rescue StandardError => error
+        failure ||= error
+      end
+      cleanup.call { stop_debugging }
+      cleanup.call { @breakpoints.close }
+      cleanup.call { @minimap.close }
+      cleanup.call { @watcher&.close }
+      cleanup.call { close_git }
+      cleanup.call { stop_language_servers }
+      cleanup.call { close_tests }
+      cleanup.call { close_tasks }
       terminal_closers = @terminals.filter_map do |current|
         Thread.new { current.close } if current.respond_to?(:close)
       end
-      terminal_closers.each(&:join)
+      terminal_closers.each { |thread| cleanup.call { thread.join } }
       @terminals.clear
-      clear_vim_states
-      @panes.each { |pane| pane.editors.each(&:dispose) }
-      @buffers.each_value(&:close)
+      cleanup.call { clear_vim_states }
+      @buffers.each_value { |buffer| cleanup.call { save_persistent_undo(buffer) } }
+      @panes.each { |pane| pane.editors.each { |current| cleanup.call { current.dispose } } }
+      @buffers.each_value { |buffer| cleanup.call { buffer.close } }
+      cleanup.call { close_recovery(clean: !@preserve_recovery && !failure) }
+      raise failure if failure
     end
 
     private
     def register_actions
       register_action("file.new") { new_buffer }
       register_action("file.save") { editor.buffer.path || editor.buffer.is_a?(MultiBuffer) ? save_buffer : palette_open(:save_as) }
+      register_action("file.encoding", description: "Encoding and Line Endings") { show_encoding_actions }
+      register_action("file.newline.lf", description: "Convert Line Endings to LF") { convert_line_endings(:lf) }
+      register_action("file.newline.crlf", description: "Convert Line Endings to CRLF") { convert_line_endings(:crlf) }
+      register_action("file.newline.cr", description: "Convert Line Endings to CR") { convert_line_endings(:cr) }
       register_action("file.close") { request_close }
       register_action("tab.close") { request_close }
       register_action("tab.close_others") { request_close(@active_pane.editors.reject { |current| current.equal?(editor) }) }
@@ -693,27 +1159,68 @@ module Canopus
       register_action("tab.reopen_closed") { reopen_closed }
       register_action("pane.close") { request_close(@active_pane.editors.dup) }
       register_action("debug.buffer_refs") { self.message = buffer_refs(editor.buffer).map { |kind, id| "#{kind}:#{id}" }.join(", ") }
+      register_action("debug.start", description: "Start Debugging") { start_debugging }
+      register_action("debug.stop", description: "Stop Debugging") { stop_debugging }
+      register_action("debug.watch.add", description: "Add Debug Watch") { show_debug_watch_add }
+      register_action("debug.watch.remove", description: "Remove Debug Watch") { show_debug_watch_remove }
+      register_action("debug.console.evaluate", description: "Evaluate in Debug Console") { show_debug_console }
+      register_action("task.run", description: "Run Task") { show_tasks }
+      register_action("task.stop", description: "Stop Task", condition: "TaskOutput") { stop_task }
+      register_action("test.refresh", description: "Refresh Tests") { refresh_tests }
       register_action("file.find") { palette_open(:files) }
       register_action("project.new_file") { project_prompt(:create_file) }
       register_action("project.new_folder") { project_prompt(:create_folder) }
       register_action("project.rename") { project_prompt(:rename_file) }
       register_action("project.trash") { project_prompt(:trash_file) }
       register_action("git.diff") { show_git_diff }
+      register_action("git.stage", description: "Stage File") { stage_git_file }
+      register_action("git.unstage", description: "Unstage File") { unstage_git_file }
+      register_action("git.stage_hunk", description: "Stage Hunk") { stage_git_hunk }
+      register_action("git.unstage_hunk", description: "Unstage Hunk") { unstage_git_hunk }
+      register_action("git.stage_line", description: "Stage Line") { stage_git_line }
+      register_action("git.unstage_line", description: "Unstage Line") { unstage_git_line }
+      register_action("git.commit", description: "Commit Staged Changes") { commit_git }
+      register_action("git.diff.toggle_mode", description: "Toggle Inline / Side-by-Side Diff") { toggle_git_diff_mode }
+      register_action("git.compare_revisions", description: "Compare Git Revisions") { show_git_revision_compare }
+      register_action("git.file_history", description: "Show File History") { show_git_file_history }
+      register_action("git.history", description: "Show Commit History") { show_git_commit_history }
+      register_action("git.fetch", description: "Fetch from Remote") { fetch_git }
+      register_action("git.pull", description: "Pull from Remote") { pull_git }
+      register_action("git.push", description: "Push to Remote") { push_git }
+      register_action("git.cancel_transfer", description: "Cancel Git Transfer") { cancel_git_transfer }
+      register_action("git.conflicts", description: "Resolve Merge Conflicts") { show_git_conflicts }
+      register_action("git.conflict.ours", description: "Resolve Conflict with Ours") { resolve_git_conflict(:ours) }
+      register_action("git.conflict.theirs", description: "Resolve Conflict with Theirs") { resolve_git_conflict(:theirs) }
+      register_action("git.conflict.both", description: "Resolve Conflict with Both") { resolve_git_conflict(:both) }
+      register_action("git.conflict.manual", description: "Resolve Conflict with Manual Edit") { resolve_git_conflict(:manual) }
       register_action("git.toggle_hunk") { toggle_git_hunk }
       register_action("git.blame") { show_git_blame }
       register_action("git.revert_hunk") { revert_current_hunk }
-      register_action("git.branches") { self.palette = {kind: :branches, query: +"", index: 0, matches: git ? git.branches : []} }
+      register_action("git.branches") { self.palette = {kind: :branches, query: +"", index: 0, matches: git_branches} }
       register_action("command.palette") { palette_open(:commands) }
       register_action("pane.split_right") { split(:horizontal) }
       register_action("pane.split_down") { split(:vertical) }
       register_action("pane.next") { focus(@panes[(@panes.index(@active_pane) + 1) % @panes.length]) }
       register_action("tab.pin") { @active_pane.pin }
-      register_action("tab.back") { @vim_states[editor]&.deactivate; @active_pane.back }
-      register_action("tab.forward") { @vim_states[editor]&.deactivate; @active_pane.forward }
+      register_action("tab.back") { @vim_states[editor]&.deactivate; @active_pane.back; invalidate_hidden_selection_ranges }
+      register_action("tab.forward") { @vim_states[editor]&.deactivate; @active_pane.forward; invalidate_hidden_selection_ranges }
       register_action("edit.undo") { editor.undo }
       register_action("edit.redo") { editor.redo }
       register_action("edit.select_all") { editor.select_all }
       register_action("edit.select_next") { editor.select_next_occurrence }
+      %i[up down].each do |direction|
+        register_action("edit.add_cursor_#{direction}", description: "Add Cursor #{direction.capitalize}", condition: "Editor && !vim_mode") do
+          editor.add_cursor(direction)
+        end
+      end
+      %i[start end].each do |edge|
+        register_action("edit.add_cursors_to_line_#{edge}s", description: "Add Cursors to Line #{edge.capitalize}s", condition: "Editor && !vim_mode") do
+          editor.add_cursors_to_selected_lines(edge)
+        end
+      end
+      register_action("edit.select_all_regex_matches", description: "Select All Regular Expression Matches", condition: "Editor && !vim_mode") do
+        palette_open(:regex_matches)
+      end
       register_action("edit.select_all_occurrences") { editor.select_next_occurrence(all: true) }
       register_action("edit.duplicate_line") { editor.duplicate_lines }
       %i[up down].each do |direction|
@@ -722,11 +1229,16 @@ module Canopus
       end
       register_action("edit.toggle_comment") { editor.toggle_comment(prefix: editor.language_document.definition.comment) }
       register_action("language.outline") { show_outline }
-      register_action("language.workspace_symbols") { palette_open(:workspace_symbols) }
+      register_action("language.workspace_symbols", description: "Workspace Symbols") { palette_open(:workspace_symbols) }
       %i[completion hover definition typeDefinition implementation references formatting codeAction signatureHelp documentSymbol inlayHint codeLens diagnostic semantic_tokens].each do |kind|
         register_action("language.#{kind}") { language_request(kind) }
       end
-      register_action("language.rename") { self.palette = {kind: :rename, query: +"", index: 0, matches: []} }
+      register_action("language.rename") { prepare_rename }
+      register_action("language.linked_editing") { linked_editing_range }
+      register_action("language.call_hierarchy") { show_call_hierarchy }
+      register_action("language.type_hierarchy") { show_type_hierarchy }
+      register_action("language.expand_selection") { expand_selection }
+      register_action("language.shrink_selection") { shrink_selection }
       register_action("editor.fold") { fold_current }
       register_action("editor.unfold") { editor.display_map.unfold(editor.primary.head) }
       register_action("edit.indent") { editor.indent }
@@ -736,11 +1248,26 @@ module Canopus
       register_action("search.replace") { palette_open(:replace_query) }
       register_action("settings.open") { open_settings }
       register_action("settings.complete") { settings_completions }
+      register_action("settings.gui", description: "Settings GUI") { settings_gui }
+      register_action("settings.gui_changed", description: "Changed Settings GUI") { settings_gui(changed_only: true) }
+      register_action("keymap.gui", description: "Keymap GUI") { keymap_gui }
+      register_action("keymap.preset", description: "Keymap Preset") { keymap_presets }
+      register_action("workspace.trust.toggle", description: "Toggle Workspace Trust") { toggle_workspace_trust }
+      register_action("workspace.trust.show", description: "Show Workspace Trust") { show_workspace_trust }
       register_action("language.diagnostics") { show_diagnostics }
+      register_action("language.restart_server") { show_language_server_restart }
       register_action("view.project") { @panels.toggle("explorer") }
       register_action("panel.explorer") { @panels.toggle("explorer") }
+      register_action("panel.scm") { @panels.toggle("scm"); refresh_scm if @panels.visible?("scm") }
       register_action("panel.search") { @panels.fetch("search").build.call }
       register_action("panel.terminal") { @terminals.empty? ? new_terminal : @panels.toggle("terminal") }
+      register_action("panel.hierarchy") { @panels.toggle("hierarchy") if @hierarchy_state }
+      register_action("panel.problems") { @panels.toggle("problems") }
+      register_action("panel.debug") { @panels.toggle("debug") }
+      register_action("panel.debug_console") { @panels.toggle("debug_console") }
+      register_action("panel.output") { toggle_task_output }
+      register_action("panel.test") { toggle_tests }
+      register_action("problems.filter") { show_problem_filter }
       [:left, :right, :bottom].each { |side| register_action("view.dock_#{side}") { toggle_dock(side) } }
       register_action("view.wrap") { editor.display_map.wrap_width = editor.display_map.wrap_map.width ? nil : 100 }
       register_action("view.theme") { self.theme = @theme.name.include?("Dark") ? "Canopus Light" : "Canopus Dark" }
@@ -753,13 +1280,46 @@ module Canopus
       end
       register_action("terminal.toggle") { call("view.terminal") }
       register_action("terminal.new") { new_terminal }
+      register_action("terminal.split_right", description: "Split Terminal Right", condition: "Terminal") { split_terminal(:horizontal) }
+      register_action("terminal.split_down", description: "Split Terminal Down", condition: "Terminal") { split_terminal(:vertical) }
       register_action("terminal.close") { request_terminal_close }
       register_action("terminal.restart") { restart_terminal }
       register_action("terminal.next") { activate_terminal((@active_terminal_index + 1) % @terminals.length) unless @terminals.empty? }
       register_action("terminal.prev") { activate_terminal((@active_terminal_index - 1) % @terminals.length) unless @terminals.empty? }
       9.times { |index| register_action("terminal.select_#{index + 1}") { activate_terminal(index) if index < @terminals.length } }
       register_action("terminal.rename") { self.palette = {kind: :terminal_rename, query: +"", index: 0, matches: []} if terminal }
-      register_action("terminal.clear") { terminal&.grid&.reset }
+      register_action("terminal.commands", description: "Show Terminal Commands", condition: "Terminal") { show_terminal_commands }
+      register_action("terminal.commands.failed", description: "Show Failed Terminal Commands", condition: "Terminal") do
+        show_terminal_commands(failed: true)
+      end
+      register_action("terminal.clear") do
+        terminal&.grid&.reset
+        terminal&.clear_commands
+      end
+    end
+
+    def inject_shell_integration(current)
+      shell = current.command_name
+      path = Tarazed::ShellIntegration.path(shell)
+      source = File.basename(shell).downcase.delete_suffix(".exe") == "fish" ? "source" : "."
+      current.input("#{source} #{Shellwords.escape(path)}\n")
+    rescue ArgumentError, IOError, SystemCallError
+      nil
+    end
+
+    def retained_terminal_commands
+      return [] unless terminal&.respond_to?(:commands) && !terminal.grid.alternate?
+      grid = terminal.grid
+      first = grid.scrollback.total - grid.scrollback.length
+      last = grid.scrollback.total + grid.rows - 1
+      terminal.commands.select { |command| command.prompt_row.between?(first, last) }
+    end
+
+    def terminal_command_label(command)
+      input = command.input.to_s.encode(Encoding::UTF_8, invalid: :replace, undef: :replace).scrub
+        .gsub(/[\x00-\x1f\x7f]+/, " ").strip
+      input = "(empty command)" if input.empty?
+      "exit #{command.exit_status}  #{input}".slice(0, 240)
     end
     def encode_layout(node)
       node[:pane] ? {pane: @panes.index(node[:pane])} : {direction: node[:direction], ratio: node.fetch(:ratio, 0.5), children: node[:children].map { |child| encode_layout(child) }}
@@ -812,7 +1372,11 @@ module Canopus
     def release_buffer(buffer, discard: false)
       return unless buffer_refs(buffer).empty?
       return if buffer.dirty? && !discard
+      @minimap.release(buffer)
+      invalidate_sticky_symbols(buffer)
       close_language_documents(buffer)
+      detach_breakpoints(buffer)
+      save_persistent_undo(buffer)
       @buffers.delete_if { |_, current| current.equal?(buffer) }
       buffer.close
     end
@@ -847,6 +1411,52 @@ module Canopus
       path
     end
 
+    def terminal_profile_command(profile)
+      return profile["command"] if profile["command"]
+      [profile["path"], *profile.fetch("args", [])] if profile["path"]
+    end
+
+    def invalidate_terminal_layout_resize
+      @terminal_resize_times&.clear
+    end
+
+    def terminal_cwd(current)
+      cwd = current.respond_to?(:cwd) ? current.cwd : current.vt.cwd
+      cwd || (current.respond_to?(:initial_cwd) ? current.initial_cwd : @root)
+    end
+
+    def terminal_layout_include?(current, node = @terminal_layout)
+      return false unless node
+      return node[:terminal].equal?(current) if node[:terminal]
+      node[:children].any? { |child| terminal_layout_include?(current, child) }
+    end
+
+    def terminal_layout_terminals(node = @terminal_layout)
+      return [] unless node
+      return [node[:terminal]] if node[:terminal]
+      node[:children].flat_map { |child| terminal_layout_terminals(child) }
+    end
+
+    def replace_terminal_leaf(node, current, replacement)
+      replace_terminal_node(node, current, {terminal: replacement})
+    end
+
+    def replace_terminal_node(node, current, replacement)
+      return unless node
+      return replacement if node[:terminal]&.equal?(current)
+      return if node[:terminal]
+      children = node[:children].map { |child| replace_terminal_node(child, current, replacement) || child }
+      node.merge(children: children)
+    end
+
+    def remove_terminal_leaf(node, current)
+      return unless node
+      return if node[:terminal]&.equal?(current)
+      return node if node[:terminal]
+      children = node[:children].filter_map { |child| remove_terminal_leaf(child, current) }
+      children.length == 1 ? children.first : node.merge(children: children)
+    end
+
     def reap_exited_terminals
       policy = @settings["terminal"]["close_on_exit"]
       @terminals.dup.each do |current|
@@ -859,20 +1469,54 @@ module Canopus
 end
 
 require_relative "workspace/session_persistable"
+require_relative "workspace/recoverable"
 require_relative "workspace/project_tree_editable"
 require_relative "workspace/file_change_aware"
 require_relative "workspace/language_server_configurable"
 require_relative "workspace/language_aware"
+require_relative "workspace/hierarchy_aware"
+require_relative "workspace/problems_aware"
 require_relative "workspace/git_aware"
+require_relative "workspace/git_staging"
+require_relative "workspace/git_diff_view"
+require_relative "workspace/git_conflict_resolution"
+require_relative "workspace/git_history"
+require_relative "workspace/git_remote"
+require_relative "workspace/git_blame"
 require_relative "workspace/project_searchable"
+require_relative "workspace/editor_configurable"
 require_relative "workspace/settings_aware"
+require_relative "workspace/keymap_aware"
+require_relative "workspace/trust"
+require_relative "workspace/auto_savable"
+require_relative "workspace/persistent_undo"
 require_relative "workspace/file_previewable"
+require_relative "workspace/debug_aware"
+require_relative "workspace/task_aware"
+require_relative "workspace/test_aware"
 Canopus::Workspace.include Canopus::Workspace::SessionPersistable
+Canopus::Workspace.include Canopus::Workspace::Recoverable
 Canopus::Workspace.include Canopus::Workspace::ProjectTreeEditable
 Canopus::Workspace.include Canopus::Workspace::FileChangeAware
 Canopus::Workspace.include Canopus::Workspace::LanguageServerConfigurable
 Canopus::Workspace.include Canopus::Workspace::LanguageAware
+Canopus::Workspace.include Canopus::Workspace::HierarchyAware
+Canopus::Workspace.include Canopus::Workspace::ProblemsAware
 Canopus::Workspace.include Canopus::Workspace::GitAware
+Canopus::Workspace.include Canopus::Workspace::GitStaging
+Canopus::Workspace.include Canopus::Workspace::GitDiffView
+Canopus::Workspace.include Canopus::Workspace::GitConflictResolution
+Canopus::Workspace.include Canopus::Workspace::GitHistory
+Canopus::Workspace.include Canopus::Workspace::GitRemote
+Canopus::Workspace.include Canopus::Workspace::GitBlame
 Canopus::Workspace.include Canopus::Workspace::ProjectSearchable
+Canopus::Workspace.include Canopus::Workspace::EditorConfigurable
 Canopus::Workspace.include Canopus::Workspace::SettingsAware
+Canopus::Workspace.include Canopus::Workspace::KeymapAware
+Canopus::Workspace.include Canopus::Workspace::TrustAware
+Canopus::Workspace.include Canopus::Workspace::AutoSavable
+Canopus::Workspace.include Canopus::Workspace::PersistentUndo
 Canopus::Workspace.include Canopus::Workspace::FilePreviewable
+Canopus::Workspace.include Canopus::Workspace::DebugAware
+Canopus::Workspace.include Canopus::Workspace::TaskAware
+Canopus::Workspace.include Canopus::Workspace::TestAware