rails-worktrees 0.7.4 → 0.9.0

data/lib/rails/worktrees/command/workspace_paths.rb

@@ -1,8 +1,11 @@
 module Rails
   module Worktrees
     class Command
-      # Resolves the default and explicit workspace path layouts.
+      # Resolves the sibling (default), workspace_root and in-repo worktrees_dir path layouts.
       module WorkspacePaths
+        INVALID_WORKTREES_DIR_MESSAGE =
+          "worktrees_dir must be a relative path inside the repository, like '.worktrees' (got %p).".freeze
+
         private
 
         def resolve_repository_context
@@ -41,9 +44,16 @@ module Rails
 
         def resolve_workspaces(repo_root, project_name)
           explicit_root = configured_workspaces_root
-          return { root: explicit_root, uses_default_root: false } if explicit_root
+          return { root: explicit_root, layout: :workspace_root, uses_default_root: false } if explicit_root
+
+          in_repo_dir = configured_worktrees_dir
+          if in_repo_dir
+            return { root: File.join(repo_root, in_repo_dir), layout: :in_repo, relative_dir: in_repo_dir,
+                     uses_default_root: false }
+          end
 
-          { root: File.join(File.dirname(repo_root), "#{project_name}.worktrees"), uses_default_root: true }
+          { root: File.join(File.dirname(repo_root), "#{project_name}.worktrees"), layout: :sibling,
+            uses_default_root: true }
         end
 
         def configured_workspaces_root
@@ -51,16 +61,37 @@ module Rails
           return expand_home(env_root) if present_path?(env_root)
 
           config_root = @configuration.workspace_root
-          return expand_home(config_root) if present_path?(config_root)
+          return unless present_path?(config_root)
+
+          if present_path?(@configuration.worktrees_dir)
+            raise Error, 'Set either workspace_root or worktrees_dir, not both.'
+          end
+
+          expand_home(config_root)
+        end
+
+        def configured_worktrees_dir
+          value = @configuration.worktrees_dir
+          return unless present_path?(value)
 
-          nil
+          normalized = Pathname(value.to_s).cleanpath
+          raise Error, format(INVALID_WORKTREES_DIR_MESSAGE, value) unless valid_worktrees_dir?(normalized)
+
+          normalized.to_s
+        end
+
+        def valid_worktrees_dir?(path)
+          first_component = path.each_filename.first
+
+          path.relative? && !path.to_s.start_with?('~') &&
+            !path.each_filename.include?('..') && !['.', '.git'].include?(first_component)
         end
 
         def target_dir_for(project_name, worktree_name, workspaces)
-          if workspaces[:uses_default_root]
-            File.join(workspaces[:root], worktree_name)
-          else
+          if workspaces[:layout] == :workspace_root
             File.join(workspaces[:root], project_name, worktree_name)
+          else
+            File.join(workspaces[:root], worktree_name)
           end
         end
 
@@ -85,7 +116,7 @@ module Rails
         end
 
         def present_path?(path)
-          !path.nil? && !path.empty?
+          !path.nil? && !path.to_s.empty?
         end
 
         def expand_home(path)

data/lib/rails/worktrees/command.rb

@@ -1,6 +1,7 @@
 require 'fileutils'
 require_relative 'command/environment_support'
 require_relative 'command/git_operations'
+require_relative 'command/in_repo_worktrees'
 require_relative 'command/name_picking'
 require_relative 'command/output'
 require_relative 'command/post_create_support'
@@ -15,9 +16,13 @@ module Rails
       DOCTOR_SUBCOMMAND = 'doctor'.freeze
       SETUP_SUBCOMMAND = 'setup'.freeze
       UPDATE_SUBCOMMAND = 'update'.freeze
+      PI_FLAG_EXEMPT_META_COMMANDS = %w[-h --help help -v --version version].freeze
+      # Command words that wt never treats as a worktree name.
+      RESERVED_WORDS = %w[help version doctor setup update teardown prune remove delete].freeze
 
       include GitOperations
       include EnvironmentSupport
+      include InRepoWorktrees
       include NamePicking
       include Output
       include PostCreateSupport
@@ -35,6 +40,7 @@ module Rails
       end
 
       def run
+        validate_pi_flag!
         meta_command_result = handle_meta_command
         return meta_command_result unless meta_command_result.nil?
 
@@ -52,10 +58,13 @@ module Rails
 
       def skip_setup? = @skip_setup
 
+      def pi? = @pi
+
       def extract_flags!
         @dry_run = extract_flag!('--dry-run')
         @force = extract_flag!('--force')
         @skip_setup = extract_flag!('--skip-setup')
+        @pi = extract_flag!('--pi')
       end
 
       def extract_flag!(flag)
@@ -89,6 +98,13 @@ module Rails
         @argv.first == UPDATE_SUBCOMMAND
       end
 
+      def validate_pi_flag!
+        return unless pi?
+        return if update_subcommand? || PI_FLAG_EXEMPT_META_COMMANDS.include?(@argv.first)
+
+        raise Error, 'The --pi flag is only supported with wt update.'
+      end
+
       def execute_requested_command
         handler = requested_command_handler
         return handler.call if handler
@@ -103,6 +119,7 @@ module Rails
         when SETUP_SUBCOMMAND then -> { execute_setup_command }
         when UPDATE_SUBCOMMAND then -> { execute_update_command }
         when 'prune' then -> { execute_prune_command }
+        when 'teardown' then -> { execute_teardown_command }
         else
           -> { execute_remove_command } if remove_subcommand?
         end
@@ -123,11 +140,16 @@ module Rails
           confirm_and_remove_target(context[:target_dir])
         end
 
-        prepare_target_parent(context[:target_dir])
+        prepare_worktree_location(context)
         attach_or_create_worktree(context)
         finish(context)
       end
 
+      def prepare_worktree_location(context)
+        ensure_worktrees_dir_ignored(context)
+        prepare_target_parent(context[:target_dir])
+      end
+
       def execute_setup_command
         validate_setup_args!
         announce_dry_run if dry_run?
@@ -138,6 +160,25 @@ module Rails
         complete_setup_flow(context, success_message: 'Setup complete')
       end
 
+      def execute_teardown_command
+        raise Error, 'Usage: wt teardown [--dry-run]' unless @argv.length == 1 && !force? && !skip_setup?
+
+        require_git_repo
+        repository = resolve_repository_context
+        if repository[:current_root] == repository[:primary_root]
+          raise Error, 'Cannot teardown the main checkout. Run wt teardown inside a linked worktree.'
+        end
+
+        teardown_worktree(repository[:current_root], use_current_env: true)
+        success(dry_run? ? 'Dry run complete' : 'Teardown complete')
+        0
+      end
+
+      def teardown_worktree(target_dir, use_current_env: false)
+        TeardownRunner.new(target_dir: target_dir, env: @env, io: { stdout: @stdout },
+                           use_current_env: use_current_env).call(dry_run: dry_run?)
+      end
+
       def execute_remove_command
         require_git_repo
         announce_dry_run if dry_run?
@@ -147,6 +188,7 @@ module Rails
         removal_status = removal_status_for(context)
 
         ensure_removable!(context, **removal_status)
+        teardown_worktree(context[:target_dir]) if removal_status[:worktree_exists]
         return complete_remove_dry_run(context, **removal_status) if dry_run?
 
         perform_remove(context, **removal_status)
@@ -200,8 +242,8 @@ module Rails
           return 1
         end
 
-        repository = resolve_repository_context
-        checks = project_maintenance_report(repository[:current_root]).checks + doctor_worktree_checks(repository)
+        current_root = canonical_path(git_capture('rev-parse', '--show-toplevel').strip)
+        checks = project_maintenance_report(current_root).checks + doctor_worktree_checks(current_root)
         print_doctor_report(checks)
 
         checks.any? { |check| check.fixable? || check.warning? } ? 1 : 0
@@ -259,7 +301,7 @@ module Rails
       end
 
       def validate_update_args!
-        raise Error, 'Usage: wt update [--dry-run] [path]' unless [1, 2].include?(@argv.length)
+        raise Error, 'Usage: wt update [--dry-run] [--pi] [path]' unless [1, 2].include?(@argv.length)
         raise Error, 'The --force flag is only supported with wt remove.' if force?
         raise Error, 'The --skip-setup flag is only supported when creating a worktree.' if skip_setup?
       end
@@ -638,19 +680,26 @@ module Rails
       end
 
       def project_maintenance_report(root)
-        ::Rails::Worktrees::ProjectMaintenance.new(root: root).call
+        ::Rails::Worktrees::ProjectMaintenance.new(root: root, pi_worktree: pi?).call
       end
 
-      def doctor_worktree_checks(repository)
+      def doctor_worktree_checks(current_root)
         [
           doctor_check(
             category: :git,
             status: :ok,
-            headline: "Git repository detected at #{repository[:current_root]}."
+            headline: "Git repository detected at #{current_root}."
           ),
           default_branch_doctor_check,
-          stale_worktree_doctor_check
-        ]
+          stale_worktree_doctor_check,
+          worktree_layout_doctor_check
+        ].compact
+      end
+
+      def worktree_layout_doctor_check
+        in_repo_worktrees_doctor_check(resolve_repository_context)
+      rescue Error => e
+        doctor_check(category: :worktree, status: :warning, headline: e.message)
       end
 
       def default_branch_doctor_check

data/lib/rails/worktrees/configuration.rb

@@ -5,6 +5,7 @@ module Rails
       CONFIGURABLE_ATTRIBUTES = %i[
         bootstrap_env
         workspace_root
+        worktrees_dir
         dev_port_range
         branch_prefix
         name_sources_path
@@ -13,6 +14,7 @@ module Rails
         post_create_command
         run_bundle_install
         run_yarn_install
+        run_playwright_install
         run_db_prepare
         run_test_db_prepare
         run_test_assets_precompile
@@ -33,10 +35,10 @@ module Rails
       DEFAULT_WORKTREE_DATABASE_SUFFIX_MAX_LENGTH = 18
 
       attr_accessor :bootstrap_env, :branch_prefix, :dev_port_range, :legacy_used_names_files,
-                    :name_sources_path, :used_names_file, :workspace_root,
+                    :name_sources_path, :used_names_file, :workspace_root, :worktrees_dir,
                     :worktree_database_suffix_max_length,
                     :post_create_command,
-                    :run_bundle_install, :run_yarn_install,
+                    :run_bundle_install, :run_yarn_install, :run_playwright_install,
                     :run_db_prepare, :run_test_db_prepare, :run_test_assets_precompile,
                     :link_credential_keys, :link_test_credential_key, :link_production_credential_key
 
@@ -50,6 +52,7 @@ module Rails
       def assign_core_defaults
         @bootstrap_env = DEFAULT_BOOTSTRAP_ENV
         @workspace_root = nil
+        @worktrees_dir = nil
         @branch_prefix = DEFAULT_BRANCH_PREFIX
         @dev_port_range = DEFAULT_DEV_PORT_RANGE
         @name_sources_path = DEFAULT_NAME_SOURCES_PATH
@@ -62,6 +65,7 @@ module Rails
         @post_create_command = nil
         @run_bundle_install = true
         @run_yarn_install = true
+        @run_playwright_install = true
         @run_db_prepare = true
         @run_test_db_prepare = true
         @run_test_assets_precompile = true

data/lib/rails/worktrees/pi_worktree_config_path.rb

@@ -0,0 +1,44 @@
+module Rails
+  module Worktrees
+    # Decides whether .pi/worktree.json under an app root can be safely read and written in place.
+    class PiWorktreeConfigPath
+      RELATIVE_PATH = '.pi/worktree.json'.freeze
+
+      def self.conflict(root)
+        new(root).conflict
+      end
+
+      def initialize(root)
+        @root = root
+        @path = File.join(root, RELATIVE_PATH)
+        @parent = File.dirname(@path)
+      end
+
+      # Returns why the config path is unsafe, or nil when it can be used.
+      def conflict
+        return 'is a symlink' if File.symlink?(@path)
+        return 'is not a regular file' if File.exist?(@path) && !File.file?(@path)
+        return "cannot be created because #{File.basename(@parent)} is not a directory" if parent_not_directory?
+        return if within_root?(nearest_existing_realpath(@parent))
+
+        'resolves outside the app through a symlinked directory'
+      end
+
+      private
+
+      def parent_not_directory?
+        (File.exist?(@parent) || File.symlink?(@parent)) && !File.directory?(@parent)
+      end
+
+      def nearest_existing_realpath(path)
+        path = File.dirname(path) until File.exist?(path)
+        File.realpath(path)
+      end
+
+      def within_root?(path)
+        root = File.realpath(@root)
+        path == root || path.start_with?("#{root}#{File::SEPARATOR}")
+      end
+    end
+  end
+end

data/lib/rails/worktrees/pi_worktree_config_updater.rb

@@ -0,0 +1,123 @@
+require 'json'
+require_relative 'pi_worktree_config_path'
+
+module Rails
+  module Worktrees
+    # Safely merges the bin/wt setup hook into the pi-worktree extension's .pi/worktree.json.
+    class PiWorktreeConfigUpdater
+      Result = Struct.new(:content, :changed, :status, :messages) do
+        def changed?
+          changed
+        end
+      end
+
+      RELATIVE_PATH = PiWorktreeConfigPath::RELATIVE_PATH
+      SETUP_COMMAND = 'bin/wt setup'.freeze
+      # Horizontal whitespace only: a newline would make the shell run two separate commands.
+      SETUP_COMMAND_PATTERN = %r{\A[ \t]*(?:\./)?bin/wt[ \t]+setup[ \t]*\z}
+
+      def self.configured?(content)
+        return false if content.nil? || !content.valid_encoding?
+
+        config = JSON.parse(content)
+        config.is_a?(Hash) && setup_hook?(config['postCreate'])
+      rescue JSON::ParserError
+        false
+      end
+
+      def self.setup_hook?(commands)
+        return false unless commands.is_a?(Array)
+
+        commands.any? { |command| command.is_a?(String) && command.match?(SETUP_COMMAND_PATTERN) }
+      end
+
+      def initialize(content:)
+        @content = content
+      end
+
+      def call
+        config = parse_config
+        return config if config.is_a?(Result)
+
+        conflict = conflict_message(config)
+        return conflict_result(conflict) if conflict
+
+        merge_setup_hook(config)
+      end
+
+      private
+
+      def parse_config
+        return {} if @content.nil?
+        unless @content.valid_encoding?
+          return conflict_result("#{RELATIVE_PATH} is not valid UTF-8; leaving it unchanged.")
+        end
+        return {} if @content.strip.empty?
+
+        config = JSON.parse(@content)
+        return config if config.is_a?(Hash)
+
+        conflict_result("#{RELATIVE_PATH} must contain a JSON object; leaving it unchanged.")
+      rescue JSON::ParserError => e
+        conflict_result("#{RELATIVE_PATH} is not valid JSON (#{e.message.lines.first.strip}); leaving it unchanged.")
+      end
+
+      def conflict_message(config)
+        if config.key?('linkEnvFiles') && config['linkEnvFiles'] != false
+          return [
+            "#{RELATIVE_PATH} sets \"linkEnvFiles\": #{JSON.generate(config['linkEnvFiles'])}, so pi-worktree " \
+            "would symlink the main checkout's .env into new worktrees before bin/wt setup runs.",
+            'Set "linkEnvFiles": false yourself to give each worktree its own DEV_PORT and ' \
+            'WORKTREE_DATABASE_SUFFIX, then rerun this command; the file was left unchanged.'
+          ]
+        end
+
+        return if !config.key?('postCreate') || string_list?(config['postCreate'])
+
+        "#{RELATIVE_PATH} postCreate must be a list of shell commands; leaving it unchanged."
+      end
+
+      def merge_setup_hook(config)
+        updated = config.dup
+        messages = [add_setup_hook(updated), disable_env_file_linking(updated)].compact
+        return identical_result if messages.empty?
+
+        Result.new("#{JSON.pretty_generate(ordered_new_config(config, updated))}\n", true, :updated, messages)
+      end
+
+      def add_setup_hook(config)
+        return if self.class.setup_hook?(config['postCreate'])
+
+        config['postCreate'] = Array(config['postCreate']) + [SETUP_COMMAND]
+        "Added \"#{SETUP_COMMAND}\" to postCreate in #{RELATIVE_PATH}."
+      end
+
+      def disable_env_file_linking(config)
+        return if config.key?('linkEnvFiles')
+
+        config['linkEnvFiles'] = false
+        "Disabled linkEnvFiles in #{RELATIVE_PATH} so each worktree keeps its own .env."
+      end
+
+      # Fresh configs list linkEnvFiles first so the safety switch is visible above the hooks.
+      def ordered_new_config(original, updated)
+        return updated unless original.empty?
+
+        { 'linkEnvFiles' => updated['linkEnvFiles'], 'postCreate' => updated['postCreate'] }
+      end
+
+      def string_list?(value)
+        value.is_a?(Array) && value.all?(String)
+      end
+
+      def identical_result
+        Result.new(@content, false, :identical,
+                   ["#{RELATIVE_PATH} already runs bin/wt setup with env-file linking disabled."])
+      end
+
+      def conflict_result(messages)
+        Result.new(@content, false, :conflict, Array(messages))
+      end
+    end
+  end
+end

data/lib/rails/worktrees/playwright_browser_check.rb

@@ -0,0 +1,56 @@
+require 'json'
+require 'open3'
+
+module Rails
+  module Worktrees
+    # Decides whether a worktree needs the Playwright Chromium build that matches
+    # the playwright package pinned in its package.json.
+    class PlaywrightBrowserCheck
+      PACKAGES = %w[playwright @playwright/test].freeze
+      DEPENDENCY_SECTIONS = %w[dependencies devDependencies].freeze
+      CLI_PATH = 'node_modules/.bin/playwright'.freeze
+      BROWSER = 'chromium'.freeze
+      INSTALL_LOCATION = /^\s*Install location:\s*(.+?)\s*$/
+      # Playwright writes this marker once a browser download has been fully extracted.
+      INSTALLATION_MARKER = 'INSTALLATION_COMPLETE'.freeze
+
+      def initialize(target_dir:, env:)
+        @target_dir = target_dir
+        @env = env
+      end
+
+      def applicable?
+        package = JSON.parse(File.read(File.join(@target_dir, 'package.json')))
+        DEPENDENCY_SECTIONS.any? do |section|
+          dependencies = package[section]
+          dependencies.is_a?(Hash) && PACKAGES.any? { |name| dependencies.key?(name) }
+        end
+      rescue Errno::ENOENT, JSON::ParserError
+        false
+      end
+
+      def cli_present?
+        File.exist?(File.join(@target_dir, CLI_PATH))
+      end
+
+      # Returns false whenever the installed state cannot be proven.
+      def installed?
+        locations = install_locations
+        !locations.empty? && locations.all? { |location| File.file?(File.join(location, INSTALLATION_MARKER)) }
+      end
+
+      private
+
+      def install_locations
+        return [] unless cli_present?
+
+        output, status = Open3.capture2e(@env, CLI_PATH, 'install', '--dry-run', BROWSER, chdir: @target_dir)
+        return [] unless status.success?
+
+        output.scan(INSTALL_LOCATION).flatten
+      rescue SystemCallError
+        []
+      end
+    end
+  end
+end

data/lib/rails/worktrees/post_create_runner.rb

@@ -3,7 +3,7 @@ require 'open3'
 module Rails
   module Worktrees
     # Runs post-create setup steps in a newly created worktree.
-    # Steps run in order: credential linking, bundle install, yarn install,
+    # Steps run in order: credential linking, bundle install, yarn install, Playwright Chromium install,
     # db:prepare (development), db:prepare (test), assets:precompile (test), assets:clobber.
     # rubocop:disable Metrics/ClassLength
     class PostCreateRunner
@@ -12,6 +12,8 @@ module Rails
           header: '📦 Installing gems...' },
         { id: :yarn, argv: %w[yarn install],
           header: '🧶 Installing JS dependencies...' },
+        { id: :playwright, argv: [PlaywrightBrowserCheck::CLI_PATH, 'install', PlaywrightBrowserCheck::BROWSER],
+          header: '🎭 Installing Playwright Chromium...' },
         { id: :db_prepare, argv: %w[bin/rails db:prepare],
           header: '🗄️  Preparing development database...', env: { 'RAILS_ENV' => 'development' } },
         { id: :test_db_prepare, argv: %w[bin/rails db:prepare],
@@ -25,6 +27,7 @@ module Rails
       STEP_CONFIG = {
         bundle: :run_bundle_install,
         yarn: :run_yarn_install,
+        playwright: :run_playwright_install,
         db_prepare: :run_db_prepare,
         test_db_prepare: :run_test_db_prepare,
         test_assets_precompile: :run_test_assets_precompile,
@@ -78,15 +81,52 @@ module Rails
         STEPS.each do |step|
           config_attr = STEP_CONFIG[step[:id]]
           next unless @configuration.public_send(config_attr)
-          next if step[:id] == :yarn && !yarn_lock_present?
+          next unless step_applicable?(step)
 
-          result = run_step(step, dry_run: dry_run)
+          result = run_built_in_step(step, dry_run: dry_run)
           return result unless result.zero?
         end
 
         0
       end
 
+      def step_applicable?(step)
+        case step[:id]
+        when :yarn then yarn_lock_present?
+        when :playwright then yarn_lock_present? && playwright_browser_check.applicable?
+        else true
+        end
+      end
+
+      def run_built_in_step(step, dry_run:)
+        return run_playwright_step(step, dry_run: dry_run) if step[:id] == :playwright
+
+        run_step(step, dry_run: dry_run)
+      end
+
+      # Always runs the real installer: it skips cached downloads itself and registers this
+      # worktree in the shared browser cache, so a later cleanup keeps its browsers.
+      def run_playwright_step(step, dry_run:)
+        check = playwright_browser_check
+        return preview_playwright_step(step, check) if dry_run
+
+        unless check.cli_present?
+          info("⚠️  Skipping Playwright Chromium: #{PlaywrightBrowserCheck::CLI_PATH} was not found.")
+          return 0
+        end
+
+        run_step(step, dry_run: false)
+      end
+
+      def preview_playwright_step(step, check)
+        info('🎭 Playwright Chromium is already installed; no download needed.') if check.installed?
+        run_step(step, dry_run: true)
+      end
+
+      def playwright_browser_check
+        PlaywrightBrowserCheck.new(target_dir: @target_dir, env: runtime_env)
+      end
+
       def run_credential_linking(dry_run:)
         # Missing peer key files are intentionally best-effort and should not abort
         # worktree setup; the linker reports those cases in its messages while real
@@ -158,7 +198,8 @@ module Rails
                        'BUNDLE_GEMFILE', 'BUNDLE_PATH', 'GEM_HOME', 'GEM_PATH',
                        'RUBY_VERSION', 'RAILS_ENV', 'NODE_ENV',
                        'XDG_STATE_HOME', 'XDG_DATA_HOME', 'XDG_CONFIG_HOME',
-                       'DEV_PORT', 'WORKTREE_DATABASE_SUFFIX')
+                       'DEV_PORT', 'WORKTREE_DATABASE_SUFFIX',
+                       'PLAYWRIGHT_BROWSERS_PATH')
       end
 
       attr_reader :runtime_env

data/lib/rails/worktrees/project_maintenance.rb

@@ -50,8 +50,9 @@ module Rails
       TEMPLATE_ROOT = File.expand_path('../../generators/rails/worktrees/templates', __dir__)
       FILE_ENCODING = 'UTF-8'.freeze
 
-      def initialize(root:)
+      def initialize(root:, pi_worktree: false)
         @root = root
+        @pi_worktree = pi_worktree
       end
 
       def call
@@ -60,7 +61,7 @@ module Rails
 
       private
 
-      attr_reader :root
+      attr_reader :root, :pi_worktree
 
       def maintenance_checks
         [
@@ -70,7 +71,8 @@ module Rails
           optional_updater_check(procfile_config) { |content| ProcfileUpdater.new(content: content).call },
           optional_updater_check(puma_config) { |content| PumaConfigUpdater.new(content: content).call },
           mise_check,
-          template_file_check(browser_wrapper_config)
+          template_file_check(browser_wrapper_config),
+          pi_worktree_check
         ]
       end
 
@@ -263,6 +265,31 @@ module Rails
         updater_result_check(config, mise_updater_result(relative_path))
       end
 
+      # Only audit .pi/worktree.json when explicitly requested or when it already runs bin/wt setup,
+      # so configs owned purely by other pi-worktree users stay untouched.
+      def pi_worktree_check
+        relative_path = PiWorktreeConfigUpdater::RELATIVE_PATH
+        path = absolute_path(relative_path)
+        content = File.file?(path) ? read_text(path) : nil
+        return unless pi_worktree || PiWorktreeConfigUpdater.configured?(content)
+
+        config = {
+          identifier: :pi_worktree,
+          category: :config,
+          relative_path: relative_path,
+          identical_headline: "#{relative_path} already runs bin/wt setup with env-file linking disabled.",
+          fixable_headline: "#{relative_path} can be updated automatically.",
+          warning_headline: "#{relative_path} needs manual review."
+        }
+        path_conflict = PiWorktreeConfigPath.conflict(root)
+        if path_conflict
+          return warning_check(config, config.fetch(:warning_headline),
+                               ["#{relative_path} #{path_conflict}; leaving it unchanged."])
+        end
+
+        updater_result_check(config, PiWorktreeConfigUpdater.new(content: content).call)
+      end
+
       def mise_updater_result(relative_path)
         MiseTomlUpdater.new(
           content: read_text(absolute_path(relative_path)),