diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml
index ee2215c9a89e4..ac3846fe4f99d 100644
--- a/.github/workflows/docker.yml
+++ b/.github/workflows/docker.yml
@@ -5,7 +5,6 @@ on:
   push:
     branches:
       - main
-      - master
   merge_group:
   release:
     types:
@@ -19,8 +18,7 @@ defaults:
     shell: bash -xeuo pipefail {0}
 
 env:
-  # odeprecated: remove 20.04 image in Homebrew >=4.7
-  VERSIONS: '["20.04", "22.04", "24.04"]'
+  VERSIONS: '["22.04", "24.04"]'
 
 jobs:
   generate-tags:
@@ -72,29 +70,19 @@ jobs:
               tags+=(
                 "ghcr.io/homebrew/ubuntu${version}:${brew_version}"
                 "ghcr.io/homebrew/ubuntu${version}:latest"
-                "homebrew/ubuntu${version}:${brew_version}"
-                "homebrew/ubuntu${version}:latest"
               )
               if [[ "${version}" == "22.04" ]]; then
                 tags+=(
                   "ghcr.io/homebrew/brew:${brew_version}"
                   "ghcr.io/homebrew/brew:latest"
-                  "homebrew/brew:${brew_version}"
-                  "homebrew/brew:latest"
                 )
               fi
             elif [[ "${GITHUB_EVENT_NAME}" == "push" &&
-                    ("${GITHUB_REF}" == "refs/heads/master" || "${GITHUB_REF}" == "refs/heads/main") &&
+                    ("${GITHUB_REF}" == "refs/heads/main") &&
                     "${version}" == "22.04" ]]; then
               tags+=(
                 "ghcr.io/homebrew/brew:main"
-                "ghcr.io/homebrew/brew:master"
                 "ghcr.io/homebrew/ubuntu${version}:main"
-                "ghcr.io/homebrew/ubuntu${version}:master"
-                "homebrew/brew:main"
-                "homebrew/brew:master"
-                "homebrew/ubuntu${version}:main"
-                "homebrew/ubuntu${version}:master"
               )
             fi
 
@@ -151,13 +139,9 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        # odeprecated: remove 20.04 image in Homebrew >=4.7
-        version: ["20.04", "22.04", "24.04"]
+        version: ["22.04", "24.04"]
         arch: ["x86_64", "arm64"]
-        exclude:
-          # odeprecated: remove 20.04 image in Homebrew >=4.7
-          - version: "20.04"
-            arch: "arm64"
+
     steps:
       - name: Checkout
         uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
@@ -179,11 +163,6 @@ jobs:
           VERSION: ${{ matrix.version }}
           PUSH: ${{ needs.generate-tags.outputs.push }}
         run: |
-          # odeprecated: remove 20.04 image in Homebrew >=4.7
-          if [[ "${VERSION}" == "20.04" ]]; then
-            echo "The homebrew/ubuntu20.04 image is deprecated and will soon be retired. Use homebrew/ubuntu24.04 or homebrew/brew." > .docker-deprecate
-          fi
-
           filter="$(printf '.["%s"]' "${VERSION}")"
           echo "push=$(jq --raw-output "${filter}" <<<"${PUSH}")" >>"${GITHUB_OUTPUT}"
 
@@ -204,18 +183,8 @@ jobs:
           build-args: version=${{ matrix.version }}
           labels: ${{ needs.generate-tags.outputs.labels }}
 
-      - name: Set environment variables
-        run: |
-          # odeprecated: remove 20.04 in Homebrew >=4.7
-          if [[ "${VERSION}" == "20.04" ]]; then
-            echo "HOMEBREW_GLIBC_TESTING=1" >> "$GITHUB_ENV"
-          fi
-        env:
-          VERSION: ${{ matrix.version }}
-          ARCH: ${{ matrix.arch }}
-
       - name: Run brew test-bot --only-setup
-        run: docker run --env HOMEBREW_GLIBC_TESTING --rm brew brew test-bot --only-setup
+        run: docker run --rm brew brew test-bot --only-setup
 
       - name: Log in to GitHub Packages (BrewTestBot)
         if: fromJSON(steps.attributes.outputs.push)
@@ -275,12 +244,6 @@ jobs:
           pattern: digest-${{ matrix.version }}-*
           merge-multiple: true
 
-      - name: Log in to Docker Hub
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
-        with:
-          username: brewtestbot
-          password: ${{ secrets.HOMEBREW_BREW_DOCKER_TOKEN }}
-
       - name: Log in to GitHub Packages (BrewTestBot)
         uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
         with:
@@ -301,10 +264,7 @@ jobs:
           done <<<"$(jq --raw-output "${filter}" <<<"${TAGS}")"
 
           image_args=("ghcr.io/homebrew/ubuntu${VERSION}@sha256:$(<"${RUNNER_TEMP}/digests/${VERSION}-x86_64")")
-          # odeprecated: remove 20.04 image in Homebrew >=4.7
-          if [[ "${VERSION}" != 20.04 ]]; then
-            image_args+=("ghcr.io/homebrew/ubuntu${VERSION}@sha256:$(<"${RUNNER_TEMP}/digests/${VERSION}-arm64")")
-          fi
+          image_args+=("ghcr.io/homebrew/ubuntu${VERSION}@sha256:$(<"${RUNNER_TEMP}/digests/${VERSION}-arm64")")
 
           attempts=0
           until docker buildx imagetools create "${tag_args[@]}" "${image_args[@]}"; do
diff --git a/AGENTS.md b/AGENTS.md
index 52e4ec563d441..759ab2f94a4a7 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -17,6 +17,10 @@ Please follow these guidelines when contributing:
   Individual test files can be passed with `--only` e.g. to test `Library/Homebrew/cmd/reinstall.rb` with `Library/Homebrew/test/cmd/reinstall_spec.rb` run `brew tests --only=cmd/reinstall`.
 - All of the above can be run with the `brew-mcp-server`
 
+### Sandbox Setup
+
+- When working in a sandboxed environment e.g. OpenAI Codex, copy the contents of `$(brew --cache)/api/` to a writable location inside the repository (for example, `tmp/cache/api/`) and `export HOMEBREW_CACHE` to that writable directory before running `brew tests`. This avoids permission errors when the suite tries to write API cache or runtime logs.
+
 ### Development Flow
 
 - Write new code (using Sorbet `sig` type signatures and `typed: strict` for new files, but never for RSpec/test/`*_spec.rb` files)
diff --git a/Library/Homebrew/brew.sh b/Library/Homebrew/brew.sh
index 9c625b2b22fba..3b87462e12918 100644
--- a/Library/Homebrew/brew.sh
+++ b/Library/Homebrew/brew.sh
@@ -618,24 +618,18 @@ then
     HOMEBREW_OS_VERSION="macOS ${HOMEBREW_MACOS_VERSION}"
   fi
 
-  # Refuse to run on pre-El Capitan
+  # Refuse to run on pre-Catalina
+  # odisabled: remove support for Catalina September (or later) 2026
   if [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -lt "${HOMEBREW_MACOS_OLDEST_ALLOWED_NUMERIC}" ]]
   then
     printf "ERROR: Your version of macOS (%s) is too old to run Homebrew!\\n" "${HOMEBREW_MACOS_VERSION}" >&2
-    if [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -lt "100700" ]]
+    if [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -lt "101500" ]]
     then
       printf "         For 10.4 - 10.6 support see: https://github.com/mistydemeo/tigerbrew\\n" >&2
     fi
     printf "\\n" >&2
   fi
 
-  # Versions before Sierra don't handle custom cert files correctly, so need a full brewed curl.
-  if [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -lt "101200" ]]
-  then
-    HOMEBREW_SYSTEM_CURL_TOO_OLD="1"
-    HOMEBREW_FORCE_BREWED_CURL="1"
-  fi
-
   # The system libressl has a bug before macOS 10.15.6 where it incorrectly handles expired roots.
   if [[ -z "${HOMEBREW_SYSTEM_CURL_TOO_OLD}" && "${HOMEBREW_MACOS_VERSION_NUMERIC}" -lt "101506" ]]
   then
@@ -643,25 +637,8 @@ then
     HOMEBREW_FORCE_BREWED_CA_CERTIFICATES="1"
   fi
 
-  # TEMP: backwards compatiblity with existing 10.11-cross image
-  # Can (probably) be removed in March 2024.
-  if [[ -n "${HOMEBREW_FAKE_EL_CAPITAN}" ]]
-  then
-    export HOMEBREW_FAKE_MACOS="10.11.6"
-  fi
-
-  if [[ "${HOMEBREW_FAKE_MACOS}" =~ ^10\.11(\.|$) ]]
-  then
-    # We only need this to work enough to update brew and build the set portable formulae, so relax the requirement.
-    HOMEBREW_MINIMUM_GIT_VERSION="2.7.4"
-  else
-    # The system Git on macOS versions before Sierra is too old for some Homebrew functionality we rely on.
-    HOMEBREW_MINIMUM_GIT_VERSION="2.14.3"
-    if [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -lt "101200" ]]
-    then
-      HOMEBREW_FORCE_BREWED_GIT="1"
-    fi
-  fi
+  # Some Git versions are too old for some Homebrew functionality we rely on.
+  HOMEBREW_MINIMUM_GIT_VERSION="2.14.3"
 else
   HOMEBREW_PRODUCT="${HOMEBREW_SYSTEM}brew"
   # Don't try to follow /etc/os-release
diff --git a/Library/Homebrew/bundle.rb b/Library/Homebrew/bundle.rb
index a1c06bcaf6aed..f213ad46994a2 100644
--- a/Library/Homebrew/bundle.rb
+++ b/Library/Homebrew/bundle.rb
@@ -57,11 +57,6 @@ def which_vscode
         @which_vscode ||= which("code-insiders", ORIGINAL_PATHS)
       end
 
-      sig { returns(T::Boolean) }
-      def whalebrew_installed?
-        @whalebrew_installed ||= which_formula?("whalebrew")
-      end
-
       sig { returns(T.nilable(Pathname)) }
       def which_go
         @which_go ||= which("go", ORIGINAL_PATHS)
@@ -149,7 +144,6 @@ def reset!
         @vscode_installed = T.let(nil, T.nilable(T::Boolean))
         @which_vscode = T.let(nil, T.nilable(Pathname))
         @which_go = T.let(nil, T.nilable(Pathname))
-        @whalebrew_installed = T.let(nil, T.nilable(T::Boolean))
         @go_installed = T.let(nil, T.nilable(T::Boolean))
         @cask_installed = T.let(nil, T.nilable(T::Boolean))
         @formula_versions_from_env = T.let(nil, T.nilable(T::Hash[String, String]))
diff --git a/Library/Homebrew/bundle/commands/dump.rb b/Library/Homebrew/bundle/commands/dump.rb
index af7c9606ad81f..9acc05625826c 100644
--- a/Library/Homebrew/bundle/commands/dump.rb
+++ b/Library/Homebrew/bundle/commands/dump.rb
@@ -10,12 +10,12 @@ module Dump
         sig {
           params(global: T::Boolean, file: T.nilable(String), describe: T::Boolean, force: T::Boolean,
                  no_restart: T::Boolean, taps: T::Boolean, formulae: T::Boolean, casks: T::Boolean,
-                 mas: T::Boolean, whalebrew: T::Boolean, vscode: T::Boolean, go: T::Boolean).void
+                 mas: T::Boolean, vscode: T::Boolean, go: T::Boolean).void
         }
-        def self.run(global:, file:, describe:, force:, no_restart:, taps:, formulae:, casks:, mas:, whalebrew:,
+        def self.run(global:, file:, describe:, force:, no_restart:, taps:, formulae:, casks:, mas:,
                      vscode:, go:)
           Homebrew::Bundle::Dumper.dump_brewfile(
-            global:, file:, describe:, force:, no_restart:, taps:, formulae:, casks:, mas:, whalebrew:, vscode:,
+            global:, file:, describe:, force:, no_restart:, taps:, formulae:, casks:, mas:, vscode:,
             go:
           )
         end
diff --git a/Library/Homebrew/bundle/commands/list.rb b/Library/Homebrew/bundle/commands/list.rb
index 5092da894eaea..32fc450e49a30 100644
--- a/Library/Homebrew/bundle/commands/list.rb
+++ b/Library/Homebrew/bundle/commands/list.rb
@@ -10,14 +10,14 @@ module Commands
       module List
         sig {
           params(global: T::Boolean, file: T.nilable(String), formulae: T::Boolean, casks: T::Boolean,
-                 taps: T::Boolean, mas: T::Boolean, whalebrew: T::Boolean, vscode: T::Boolean,
+                 taps: T::Boolean, mas: T::Boolean, vscode: T::Boolean,
                  go: T::Boolean).void
         }
-        def self.run(global:, file:, formulae:, casks:, taps:, mas:, whalebrew:, vscode:, go:)
+        def self.run(global:, file:, formulae:, casks:, taps:, mas:, vscode:, go:)
           parsed_entries = Brewfile.read(global:, file:).entries
           Homebrew::Bundle::Lister.list(
             parsed_entries,
-            formulae:, casks:, taps:, mas:, whalebrew:, vscode:, go:,
+            formulae:, casks:, taps:, mas:, vscode:, go:,
           )
         end
       end
diff --git a/Library/Homebrew/bundle/dsl.rb b/Library/Homebrew/bundle/dsl.rb
index 9fb4054b7945f..299dac6031761 100644
--- a/Library/Homebrew/bundle/dsl.rb
+++ b/Library/Homebrew/bundle/dsl.rb
@@ -71,12 +71,6 @@ def mas(name, options = {})
         @entries << Entry.new(:mas, name, id:)
       end
 
-      def whalebrew(name)
-        raise "name(#{name.inspect}) should be a String object" unless name.is_a? String
-
-        @entries << Entry.new(:whalebrew, name)
-      end
-
       def vscode(name)
         raise "name(#{name.inspect}) should be a String object" unless name.is_a? String
 
diff --git a/Library/Homebrew/bundle/dumper.rb b/Library/Homebrew/bundle/dumper.rb
index 001d521b9fcbc..d5b903de5069c 100644
--- a/Library/Homebrew/bundle/dumper.rb
+++ b/Library/Homebrew/bundle/dumper.rb
@@ -22,17 +22,15 @@ module Dumper
           taps:       T::Boolean,
           casks:      T::Boolean,
           mas:        T::Boolean,
-          whalebrew:  T::Boolean,
           vscode:     T::Boolean,
           go:         T::Boolean,
         ).returns(String)
       }
-      def self.build_brewfile(describe:, no_restart:, formulae:, taps:, casks:, mas:, whalebrew:, vscode:, go:)
+      def self.build_brewfile(describe:, no_restart:, formulae:, taps:, casks:, mas:, vscode:, go:)
         require "bundle/tap_dumper"
         require "bundle/formula_dumper"
         require "bundle/cask_dumper"
         require "bundle/mac_app_store_dumper"
-        require "bundle/whalebrew_dumper"
         require "bundle/vscode_extension_dumper"
         require "bundle/go_dumper"
 
@@ -41,7 +39,6 @@ def self.build_brewfile(describe:, no_restart:, formulae:, taps:, casks:, mas:,
         content << FormulaDumper.dump(describe:, no_restart:) if formulae
         content << CaskDumper.dump(describe:) if casks
         content << MacAppStoreDumper.dump if mas
-        content << WhalebrewDumper.dump if whalebrew
         content << VscodeExtensionDumper.dump if vscode
         content << GoDumper.dump if go
         "#{content.reject(&:empty?).join("\n")}\n"
@@ -58,16 +55,15 @@ def self.build_brewfile(describe:, no_restart:, formulae:, taps:, casks:, mas:,
           taps:       T::Boolean,
           casks:      T::Boolean,
           mas:        T::Boolean,
-          whalebrew:  T::Boolean,
           vscode:     T::Boolean,
           go:         T::Boolean,
         ).void
       }
       def self.dump_brewfile(global:, file:, describe:, force:, no_restart:, formulae:, taps:, casks:, mas:,
-                             whalebrew:, vscode:, go:)
+                             vscode:, go:)
         path = brewfile_path(global:, file:)
         can_write_to_brewfile?(path, force:)
-        content = build_brewfile(describe:, no_restart:, taps:, formulae:, casks:, mas:, whalebrew:, vscode:, go:)
+        content = build_brewfile(describe:, no_restart:, taps:, formulae:, casks:, mas:, vscode:, go:)
         write_file path, content
       end
 
diff --git a/Library/Homebrew/bundle/installer.rb b/Library/Homebrew/bundle/installer.rb
index 9d6399ff38c54..64ab091ebd30a 100644
--- a/Library/Homebrew/bundle/installer.rb
+++ b/Library/Homebrew/bundle/installer.rb
@@ -5,7 +5,6 @@
 require "bundle/formula_installer"
 require "bundle/cask_installer"
 require "bundle/mac_app_store_installer"
-require "bundle/whalebrew_installer"
 require "bundle/vscode_extension_installer"
 require "bundle/go_installer"
 require "bundle/tap_installer"
@@ -37,8 +36,6 @@ def self.install!(entries, global: false, file: nil, no_lock: false, no_upgrade:
           when :mas
             args << entry.options[:id]
             Homebrew::Bundle::MacAppStoreInstaller
-          when :whalebrew
-            Homebrew::Bundle::WhalebrewInstaller
           when :vscode
             Homebrew::Bundle::VscodeExtensionInstaller
           when :go
diff --git a/Library/Homebrew/bundle/lister.rb b/Library/Homebrew/bundle/lister.rb
index 75ff8cc819e5c..b2a94539451ba 100644
--- a/Library/Homebrew/bundle/lister.rb
+++ b/Library/Homebrew/bundle/lister.rb
@@ -6,24 +6,23 @@ module Bundle
     module Lister
       sig {
         params(entries: T::Array[Homebrew::Bundle::Dsl::Entry], formulae: T::Boolean, casks: T::Boolean,
-               taps: T::Boolean, mas: T::Boolean, whalebrew: T::Boolean, vscode: T::Boolean, go: T::Boolean).void
+               taps: T::Boolean, mas: T::Boolean, vscode: T::Boolean, go: T::Boolean).void
       }
-      def self.list(entries, formulae:, casks:, taps:, mas:, whalebrew:, vscode:, go:)
+      def self.list(entries, formulae:, casks:, taps:, mas:, vscode:, go:)
         entries.each do |entry|
-          puts entry.name if show?(entry.type, formulae:, casks:, taps:, mas:, whalebrew:, vscode:, go:)
+          puts entry.name if show?(entry.type, formulae:, casks:, taps:, mas:, vscode:, go:)
         end
       end
 
       sig {
         params(type: Symbol, formulae: T::Boolean, casks: T::Boolean, taps: T::Boolean, mas: T::Boolean,
-               whalebrew: T::Boolean, vscode: T::Boolean, go: T::Boolean).returns(T::Boolean)
+               vscode: T::Boolean, go: T::Boolean).returns(T::Boolean)
       }
-      private_class_method def self.show?(type, formulae:, casks:, taps:, mas:, whalebrew:, vscode:, go:)
+      private_class_method def self.show?(type, formulae:, casks:, taps:, mas:, vscode:, go:)
         return true if formulae && type == :brew
         return true if casks && type == :cask
         return true if taps && type == :tap
         return true if mas && type == :mas
-        return true if whalebrew && type == :whalebrew
         return true if vscode && type == :vscode
         return true if go && type == :go
 
diff --git a/Library/Homebrew/bundle/skipper.rb b/Library/Homebrew/bundle/skipper.rb
index 1261b5a621a10..bd2ddf3fa39c5 100644
--- a/Library/Homebrew/bundle/skipper.rb
+++ b/Library/Homebrew/bundle/skipper.rb
@@ -42,7 +42,7 @@ def skipped_entries
           return @skipped_entries if @skipped_entries
 
           @skipped_entries ||= T.let({}, T.nilable(T::Hash[Symbol, T.nilable(T::Array[String])]))
-          [:brew, :cask, :mas, :tap, :whalebrew].each do |type|
+          [:brew, :cask, :mas, :tap].each do |type|
             @skipped_entries[type] =
               ENV["HOMEBREW_BUNDLE_#{type.to_s.upcase}_SKIP"]&.split
           end
diff --git a/Library/Homebrew/bundle/whalebrew_dumper.rb b/Library/Homebrew/bundle/whalebrew_dumper.rb
deleted file mode 100644
index 12ce6b99a41d4..0000000000000
--- a/Library/Homebrew/bundle/whalebrew_dumper.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "utils/output"
-
-module Homebrew
-  module Bundle
-    module WhalebrewDumper
-      extend Utils::Output::Mixin
-
-      sig { void }
-      def self.reset!
-        @images = T.let(nil, T.nilable(T::Array[String]))
-      end
-
-      sig { returns(T::Array[T.nilable(String)]) }
-      def self.images
-        return [] unless Bundle.whalebrew_installed?
-
-        odisabled "`brew bundle` `whalebrew` support", "using `whalebrew` directly"
-        @images ||= T.let(
-          `whalebrew list 2>/dev/null`.split("\n")
-                                      .reject { |line| line.start_with?("COMMAND ") }
-                                      .filter_map { |line| line.split(/\s+/).last }
-                                      .uniq,
-          T.nilable(T::Array[String]),
-        )
-      end
-
-      sig { returns(String) }
-      def self.dump
-        images.map { |image| "whalebrew \"#{image}\"" }.join("\n")
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/bundle/whalebrew_installer.rb b/Library/Homebrew/bundle/whalebrew_installer.rb
deleted file mode 100644
index 21bb0d2adfb6f..0000000000000
--- a/Library/Homebrew/bundle/whalebrew_installer.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-# typed: true # rubocop:todo Sorbet/StrictSigil
-# frozen_string_literal: true
-
-require "utils/output"
-
-module Homebrew
-  module Bundle
-    module WhalebrewInstaller
-      extend Utils::Output::Mixin
-
-      def self.reset!
-        @installed_images = nil
-      end
-
-      def self.preinstall!(name, verbose: false, **_options)
-        unless Bundle.whalebrew_installed?
-          puts "Installing whalebrew. It is not currently installed." if verbose
-          Bundle.brew("install", "--formula", "whalebrew", verbose:)
-          raise "Unable to install #{name} app. Whalebrew installation failed." unless Bundle.whalebrew_installed?
-        end
-
-        if image_installed?(name)
-          puts "Skipping install of #{name} app. It is already installed." if verbose
-          return false
-        end
-
-        true
-      end
-
-      def self.install!(name, preinstall: true, verbose: false, force: false, **_options)
-        odisabled "`brew bundle` `whalebrew` support", "using `whalebrew` directly"
-        return true unless preinstall
-
-        puts "Installing #{name} image. It is not currently installed." if verbose
-
-        return false unless Bundle.system "whalebrew", "install", name, verbose: verbose
-
-        installed_images << name
-        true
-      end
-
-      def self.image_installed?(image)
-        installed_images.include? image
-      end
-
-      def self.installed_images
-        require "bundle/whalebrew_dumper"
-        @installed_images ||= Homebrew::Bundle::WhalebrewDumper.images
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/cask/dsl.rb b/Library/Homebrew/cask/dsl.rb
index 6dac4e258543e..70d96cf784e09 100644
--- a/Library/Homebrew/cask/dsl.rb
+++ b/Library/Homebrew/cask/dsl.rb
@@ -105,7 +105,6 @@ class DSL
       :disable_replacement_formula,
       :livecheck,
       :livecheck_defined?,
-      :livecheckable?, # TODO: remove once `#livecheckable?` was odisabled and is now removed
       :no_autobump!,
       :autobump?,
       :no_autobump_message,
@@ -575,14 +574,6 @@ def livecheck(&block)
       @livecheck
     end
 
-    # Whether the cask contains a `livecheck` block. This is a legacy alias
-    # for `#livecheck_defined?`.
-    sig { returns(T::Boolean) }
-    def livecheckable?
-      odisabled "`livecheckable?`", "`livecheck_defined?`"
-      @livecheck_defined == true
-    end
-
     # Excludes the cask from autobump list.
     #
     # TODO: limit this method to the official taps only
@@ -624,9 +615,6 @@ def deprecate!(date:, because:, replacement: nil, replacement_formula: nil, repl
         raise ArgumentError, "more than one of replacement, replacement_formula and/or replacement_cask specified!"
       end
 
-      # odeprecate: remove this remapping when the :unsigned reason is removed
-      because = :fails_gatekeeper_check if because == :unsigned
-
       if replacement
         odeprecated(
           "deprecate!(:replacement)",
diff --git a/Library/Homebrew/cask/dsl/caveats.rb b/Library/Homebrew/cask/dsl/caveats.rb
index 4c4865c2f75b2..c61c2d575493a 100644
--- a/Library/Homebrew/cask/dsl/caveats.rb
+++ b/Library/Homebrew/cask/dsl/caveats.rb
@@ -57,7 +57,7 @@ def eval_caveats(&block)
       end
 
       caveat :kext do
-        next if MacOS.version < :high_sierra
+        next if MacOS.version < :sonoma
 
         navigation_path = if MacOS.version >= :ventura
           "System Settings → Privacy & Security"
diff --git a/Library/Homebrew/cask/dsl/conflicts_with.rb b/Library/Homebrew/cask/dsl/conflicts_with.rb
index 0e5aec8342a6d..22031615d5464 100644
--- a/Library/Homebrew/cask/dsl/conflicts_with.rb
+++ b/Library/Homebrew/cask/dsl/conflicts_with.rb
@@ -11,7 +11,7 @@ class DSL
     class ConflictsWith < SimpleDelegator
       VALID_KEYS = [:cask].freeze
 
-      ODEPRECATED_KEYS = [
+      ODISABLED_KEYS = [
         :formula,
         :macos,
         :arch,
@@ -21,10 +21,10 @@ class ConflictsWith < SimpleDelegator
 
       sig { params(options: T.anything).void }
       def initialize(**options)
-        options.assert_valid_keys(*VALID_KEYS, *ODEPRECATED_KEYS)
+        options.assert_valid_keys(*VALID_KEYS, *ODISABLED_KEYS)
 
-        options.keys.intersection(ODEPRECATED_KEYS).each do |key|
-          ::Utils::Output.odeprecated "conflicts_with #{key}:"
+        options.keys.intersection(ODISABLED_KEYS).each do |key|
+          ::Utils::Output.odisabled "conflicts_with #{key}:"
         end
 
         conflicts = options.transform_values { |v| Set.new(Kernel.Array(v)) }
diff --git a/Library/Homebrew/cli/parser.rb b/Library/Homebrew/cli/parser.rb
index 9315f346f53b2..429e216ed392c 100644
--- a/Library/Homebrew/cli/parser.rb
+++ b/Library/Homebrew/cli/parser.rb
@@ -202,28 +202,48 @@ def initialize(cmd = nil, &block)
       end
 
       sig {
-        params(names: String, description: T.nilable(String), replacement: T.untyped, env: T.untyped,
-               depends_on: T.nilable(String), method: Symbol, hidden: T::Boolean, disable: T::Boolean).void
+        params(names: String, description: T.nilable(String), env: T.untyped,
+               depends_on: T.nilable(String), method: Symbol,
+               hidden: T::Boolean, replacement: T.nilable(T.any(String, FalseClass)),
+               odeprecated: T::Boolean, odisabled: T::Boolean, disable: T::Boolean).void
       }
-      def switch(*names, description: nil, replacement: nil, env: nil, depends_on: nil,
-                 method: :on, hidden: false, disable: false)
+      def switch(*names, description: nil, env: nil,
+                 depends_on: nil, method: :on,
+                 hidden: false, replacement: nil,
+                 odeprecated: false, odisabled: false, disable: false)
         global_switch = names.first.is_a?(Symbol)
         return if global_switch
 
+        if disable
+          # this odeprecated should turn into odisabled in 4.8.0
+          odeprecated "disable:", "odisabled:"
+          odisabled = disable
+        end
+        if !odeprecated && !odisabled && replacement
+          # this odeprecated should turn into odisabled in 4.8.0
+          odeprecated "replacement: without :odeprecated or :odisabled",
+                      "replacement: with :odeprecated or :odisabled"
+          odeprecated = true
+        end
+        hidden = true if odisabled || odeprecated
+
         description = option_description(description, *names, hidden:)
         env, counterpart = env
         if env && @non_global_processed_options.any?
           affix = counterpart ? " and `#{counterpart}` is passed." : "."
           description += " Enabled by default if `$HOMEBREW_#{env.upcase}` is set#{affix}"
         end
-        if replacement || disable
-          description += " (#{disable ? "disabled" : "deprecated"}#{"; replaced by #{replacement}" if replacement})"
+        if odeprecated || odisabled
+          description += " (#{odisabled ? "disabled" : "deprecated"}#{"; replaced by #{replacement}" if replacement})"
         end
-        process_option(*names, description, type: :switch, hidden:) unless disable
+        process_option(*names, description, type: :switch, hidden:) unless odisabled
 
         @parser.public_send(method, *names, *wrap_option_desc(description)) do |value|
           # This odeprecated should stick around indefinitely.
-          odeprecated "the `#{names.first}` switch", replacement, disable: disable if !replacement.nil? || disable
+          replacement_string = replacement if replacement
+          if odeprecated || odisabled
+            odeprecated "the `#{names.first}` switch", replacement_string, disable: odisabled
+          end
           value = true if names.none? { |name| name.start_with?("--[no-]") }
 
           set_switch(*names, value:, from: :args)
diff --git a/Library/Homebrew/cmd/bundle.rb b/Library/Homebrew/cmd/bundle.rb
index ec1408da39fcb..60750e4436fd7 100755
--- a/Library/Homebrew/cmd/bundle.rb
+++ b/Library/Homebrew/cmd/bundle.rb
@@ -10,14 +10,14 @@ class Bundle < AbstractCommand
         usage_banner <<~EOS
           `bundle` [<subcommand>]
 
-          Bundler for non-Ruby dependencies from Homebrew, Homebrew Cask, Mac App Store, Whalebrew, Visual Studio Code (and forks/variants) and Go packages.
+          Bundler for non-Ruby dependencies from Homebrew, Homebrew Cask, Mac App Store, Visual Studio Code (and forks/variants) and Go packages.
 
           `brew bundle` [`install`]:
           Install and upgrade (by default) all dependencies from the `Brewfile`.
 
           You can specify the `Brewfile` location using `--file` or by setting the `$HOMEBREW_BUNDLE_FILE` environment variable.
 
-          You can skip the installation of dependencies by adding space-separated values to one or more of the following environment variables: `$HOMEBREW_BUNDLE_BREW_SKIP`, `$HOMEBREW_BUNDLE_CASK_SKIP`, `$HOMEBREW_BUNDLE_MAS_SKIP`, `$HOMEBREW_BUNDLE_WHALEBREW_SKIP`, `$HOMEBREW_BUNDLE_TAP_SKIP`.
+          You can skip the installation of dependencies by adding space-separated values to one or more of the following environment variables: `$HOMEBREW_BUNDLE_BREW_SKIP`, `$HOMEBREW_BUNDLE_CASK_SKIP`, `$HOMEBREW_BUNDLE_MAS_SKIP`, `$HOMEBREW_BUNDLE_TAP_SKIP`.
 
           `brew bundle upgrade`:
           Shorthand for `brew bundle install --upgrade`.
@@ -46,10 +46,10 @@ class Bundle < AbstractCommand
           Edit the `Brewfile` in your editor.
 
           `brew bundle add` <name> [...]:
-          Add entries to your `Brewfile`. Adds formulae by default. Use `--cask`, `--tap`, `--whalebrew` or `--vscode` to add the corresponding entry instead.
+          Add entries to your `Brewfile`. Adds formulae by default. Use `--cask`, `--tap` or `--vscode` to add the corresponding entry instead.
 
           `brew bundle remove` <name> [...]:
-          Remove entries that match `name` from your `Brewfile`. Use `--formula`, `--cask`, `--tap`, `--mas`, `--whalebrew` or `--vscode` to remove only entries of the corresponding type. Passing `--formula` also removes matches against formula aliases and old formula names.
+          Remove entries that match `name` from your `Brewfile`. Use `--formula`, `--cask`, `--tap`, `--mas` or `--vscode` to remove only entries of the corresponding type. Passing `--formula` also removes matches against formula aliases and old formula names.
 
           `brew bundle exec` [`--check`] <command>:
           Run an external command in an isolated build environment based on the `Brewfile` dependencies.
@@ -105,8 +105,6 @@ class Bundle < AbstractCommand
                description: "`list`, `dump` or `cleanup` Homebrew tap dependencies."
         switch "--mas",
                description: "`list` or `dump` Mac App Store dependencies."
-        switch "--whalebrew",
-               description: "`list` or `dump` Whalebrew dependencies."
         switch "--vscode",
                description: "`list`, `dump` or `cleanup` VSCode (and forks/variants) extensions."
         switch "--go",
@@ -165,8 +163,7 @@ def run
         zap = args.zap?
         Homebrew::Bundle.upgrade_formulae = args.upgrade_formulae
 
-        no_type_args = [args.formulae?, args.casks?, args.taps?, args.mas?, args.whalebrew?, args.vscode?,
-                        args.go?].none?
+        no_type_args = [args.formulae?, args.casks?, args.taps?, args.mas?, args.vscode?, args.go?].none?
 
         if args.install?
           if [nil, "install", "upgrade"].include?(subcommand)
@@ -218,7 +215,6 @@ def run
             formulae:   args.formulae? || no_type_args,
             casks:      args.casks? || no_type_args,
             mas:        args.mas? || no_type_args,
-            whalebrew:  args.whalebrew?,
             vscode:,
             go:         args.go? || no_type_args
           )
@@ -242,25 +238,23 @@ def run
           Homebrew::Bundle::Commands::List.run(
             global:,
             file:,
-            formulae:  args.formulae? || args.all? || no_type_args,
-            casks:     args.casks? || args.all?,
-            taps:      args.taps? || args.all?,
-            mas:       args.mas? || args.all?,
-            whalebrew: args.whalebrew? || args.all?,
-            vscode:    args.vscode? || args.all?,
-            go:        args.go? || args.all?,
+            formulae: args.formulae? || args.all? || no_type_args,
+            casks:    args.casks? || args.all?,
+            taps:     args.taps? || args.all?,
+            mas:      args.mas? || args.all?,
+            vscode:   args.vscode? || args.all?,
+            go:       args.go? || args.all?,
           )
         when "add", "remove"
           # We intentionally omit the s from `brews`, `casks`, and `taps` for ease of handling later.
           type_hash = {
-            brew:      args.formulae?,
-            cask:      args.casks?,
-            tap:       args.taps?,
-            mas:       args.mas?,
-            whalebrew: args.whalebrew?,
-            vscode:    args.vscode?,
-            go:        args.go?,
-            none:      no_type_args,
+            brew:   args.formulae?,
+            cask:   args.casks?,
+            tap:    args.taps?,
+            mas:    args.mas?,
+            vscode: args.vscode?,
+            go:     args.go?,
+            none:   no_type_args,
           }
           selected_types = type_hash.select { |_, v| v }.keys
           raise UsageError, "`#{subcommand}` supports only one type of entry at a time." if selected_types.count != 1
diff --git a/Library/Homebrew/cmd/fetch.rb b/Library/Homebrew/cmd/fetch.rb
index 8683820dae0da..f66cf985a2b2c 100644
--- a/Library/Homebrew/cmd/fetch.rb
+++ b/Library/Homebrew/cmd/fetch.rb
@@ -47,11 +47,9 @@ class FetchCmd < AbstractCommand
         switch "--force-bottle",
                description: "Download a bottle if it exists for the current or newest version of macOS, " \
                             "even if it would not be used during installation."
-        # odeprecated deprecate for 4.7.0
         switch "--[no-]quarantine",
-               description: "Disable/enable quarantining of downloads (default: enabled).",
                env:         :cask_opts_quarantine,
-               hidden:      true
+               odeprecated: true
         switch "--formula", "--formulae",
                description: "Treat all named arguments as formulae."
         switch "--cask", "--casks",
diff --git a/Library/Homebrew/cmd/install.rb b/Library/Homebrew/cmd/install.rb
index c4d004aa8faf7..56b3cf9388635 100644
--- a/Library/Homebrew/cmd/install.rb
+++ b/Library/Homebrew/cmd/install.rb
@@ -147,11 +147,9 @@ class InstallCmd < AbstractCommand
             description: "Require all casks to have a checksum.",
             env:         :cask_opts_require_sha,
           }],
-          # odeprecated deprecate for 4.7.0
           [:switch, "--[no-]quarantine", {
-            description: "Disable/enable quarantining of downloads (default: enabled).",
             env:         :cask_opts_quarantine,
-            hidden:      true,
+            odeprecated: true,
           }],
           [:switch, "--adopt", {
             description: "Adopt existing artifacts in the destination that are identical to those being installed. " \
diff --git a/Library/Homebrew/cmd/reinstall.rb b/Library/Homebrew/cmd/reinstall.rb
index 9bb4af01b05f0..f8dc91fb95ced 100644
--- a/Library/Homebrew/cmd/reinstall.rb
+++ b/Library/Homebrew/cmd/reinstall.rb
@@ -87,11 +87,9 @@ class Reinstall < AbstractCommand
             description: "Require all casks to have a checksum.",
             env:         :cask_opts_require_sha,
           }],
-          # odeprecated deprecate for 4.7.0
           [:switch, "--[no-]quarantine", {
-            description: "Disable/enable quarantining of downloads (default: enabled).",
             env:         :cask_opts_quarantine,
-            hidden:      true,
+            odeprecated: true,
           }],
           [:switch, "--adopt", {
             description: "Adopt existing artifacts in the destination that are identical to those being installed. " \
diff --git a/Library/Homebrew/cmd/tap.rb b/Library/Homebrew/cmd/tap.rb
index d29cda4a63411..8e7b9f48e33bf 100644
--- a/Library/Homebrew/cmd/tap.rb
+++ b/Library/Homebrew/cmd/tap.rb
@@ -23,16 +23,6 @@ class TapCmd < AbstractCommand
           assumptions, so taps can be cloned from places other than GitHub and
           using protocols other than HTTPS, e.g. SSH, git, HTTP, FTP(S), rsync.
         EOS
-        switch "--full",
-               description: "Convert a shallow clone to a full clone without untapping. Taps are only cloned as " \
-                            "shallow clones if `--shallow` was originally passed.",
-               replacement: false,
-               disable:     true
-        switch "--shallow",
-               description: "Fetch tap as a shallow clone rather than a full clone. Useful for continuous " \
-                            "integration.",
-               replacement: false,
-               disable:     true
         switch "--custom-remote",
                description: "Install or change a tap with a custom remote. Useful for mirrors."
         switch "--repair",
diff --git a/Library/Homebrew/cmd/update.sh b/Library/Homebrew/cmd/update.sh
index d9232b5c49acc..17e1ec29c4282 100644
--- a/Library/Homebrew/cmd/update.sh
+++ b/Library/Homebrew/cmd/update.sh
@@ -32,22 +32,12 @@ macos_version_name() {
     echo "monterey"
   elif [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -ge "110000" ]]
   then
+    # odisabled: remove support for Big Sur and macOS x86_64 September (or later) 2027
     echo "big_sur"
   elif [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -ge "101500" ]]
   then
+    # odisabled: remove support for Catalina September (or later) 2026
     echo "catalina"
-  elif [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -ge "101400" ]]
-  then
-    echo "mojave"
-  elif [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -ge "101300" ]]
-  then
-    echo "high_sierra"
-  elif [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -ge "101200" ]]
-  then
-    echo "sierra"
-  elif [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -ge "101100" ]]
-  then
-    echo "el_capitan"
   fi
 }
 
diff --git a/Library/Homebrew/cmd/upgrade.rb b/Library/Homebrew/cmd/upgrade.rb
index 58e4fe43f3769..026452f4f6f98 100644
--- a/Library/Homebrew/cmd/upgrade.rb
+++ b/Library/Homebrew/cmd/upgrade.rb
@@ -108,11 +108,9 @@ class UpgradeCmd < AbstractCommand
             description: "Require all casks to have a checksum.",
             env:         :cask_opts_require_sha,
           }],
-          # odeprecated deprecate for 4.7.0
           [:switch, "--[no-]quarantine", {
-            description: "Disable/enable quarantining of downloads (default: enabled).",
             env:         :cask_opts_quarantine,
-            hidden:      true,
+            odeprecated: true,
           }],
         ].each do |args|
           options = args.pop
diff --git a/Library/Homebrew/deprecate_disable.rb b/Library/Homebrew/deprecate_disable.rb
index 82a3e980a7c36..3278bf98ec5b8 100644
--- a/Library/Homebrew/deprecate_disable.rb
+++ b/Library/Homebrew/deprecate_disable.rb
@@ -29,8 +29,6 @@ module DeprecateDisable
     unmaintained:             "is not maintained upstream",
     fails_gatekeeper_check:   "does not pass the macOS Gatekeeper check",
     unreachable:              "is no longer reliably reachable upstream",
-    # odeprecate: remove the unsigned reason in a future release
-    unsigned:                 "is unsigned or does not meet signature requirements",
   }.freeze, T::Hash[Symbol, String])
 
   # One year when << or >> to Date.today.
@@ -70,9 +68,6 @@ def message(formula_or_cask)
       formula_or_cask.disable_reason
     end
 
-    # odeprecate: remove this remapping in a future release
-    reason = :fails_gatekeeper_check if reason == :unsigned
-
     reason = if formula_or_cask.is_a?(Formula) && FORMULA_DEPRECATE_DISABLE_REASONS.key?(reason)
       FORMULA_DEPRECATE_DISABLE_REASONS[reason]
     elsif formula_or_cask.is_a?(Cask::Cask) && CASK_DEPRECATE_DISABLE_REASONS.key?(reason)
diff --git a/Library/Homebrew/dev-cmd/audit.rb b/Library/Homebrew/dev-cmd/audit.rb
index 60ad31dea5c06..17e878a312092 100644
--- a/Library/Homebrew/dev-cmd/audit.rb
+++ b/Library/Homebrew/dev-cmd/audit.rb
@@ -48,14 +48,6 @@ class Audit < AbstractCommand
                description: "Run various additional style checks to determine if a new formula or cask is eligible " \
                             "for Homebrew. This should be used when creating new formulae or casks and implies " \
                             "`--strict` and `--online`."
-        switch "--new-formula",
-               replacement: "--new",
-               disable:     true,
-               hidden:      true
-        switch "--new-cask",
-               replacement: "--new",
-               disable:     true,
-               hidden:      true
         switch "--[no-]signing",
                description: "Audit for app signatures, which are required by macOS on ARM."
         switch "--token-conflicts",
@@ -106,7 +98,7 @@ class Audit < AbstractCommand
 
       sig { override.void }
       def run
-        odeprecated "`brew audit --token-conflicts`" if args.token_conflicts?
+        odisabled "`brew audit --token-conflicts`" if args.token_conflicts?
 
         Formulary.enable_factory_cache!
 
diff --git a/Library/Homebrew/dev-cmd/formula-analytics.rb b/Library/Homebrew/dev-cmd/formula-analytics.rb
index 17675fde3287c..e96c643203ccf 100755
--- a/Library/Homebrew/dev-cmd/formula-analytics.rb
+++ b/Library/Homebrew/dev-cmd/formula-analytics.rb
@@ -371,8 +371,10 @@ def format_os_version_dimension(dimension)
                              .gsub(/^macOS ?/, "")
                              .gsub(/ \(.+\)$/, "")
 
-        if (macos_pretty_name = ::MacOSVersion.analytics_pretty_name(dimension))
-          return macos_pretty_name
+        begin
+          return ::MacOSVersion.new(dimension).pretty_name
+        rescue MacOSVersion::Error
+          nil
         end
 
         case dimension
diff --git a/Library/Homebrew/dev-cmd/tests.rb b/Library/Homebrew/dev-cmd/tests.rb
index 0780be102d513..2c4d5a0b7af3b 100644
--- a/Library/Homebrew/dev-cmd/tests.rb
+++ b/Library/Homebrew/dev-cmd/tests.rb
@@ -60,13 +60,17 @@ def run
 
           only = args.only
           files = if only
-            test_name, line = only.split(":", 2)
-
-            if line.nil?
-              Dir.glob("test/{#{test_name},#{test_name}/**/*}_spec.rb")
-            else
-              parallel = false
-              ["test/#{test_name}_spec.rb:#{line}"]
+            only.split(",").flat_map do |test|
+              test_name, line = test.split(":", 2)
+              tests = if line.present?
+                parallel = false
+                ["test/#{test_name}_spec.rb:#{line}"]
+              else
+                Dir.glob("test/{#{test_name},#{test_name}/**/*}_spec.rb")
+              end
+              raise UsageError, "Invalid `--only` argument: #{test}" if tests.blank?
+
+              tests
             end
           elsif args.changed?
             changed_test_files
diff --git a/Library/Homebrew/development_tools.rb b/Library/Homebrew/development_tools.rb
index 66594cdddacea..5b173fb2e05f1 100644
--- a/Library/Homebrew/development_tools.rb
+++ b/Library/Homebrew/development_tools.rb
@@ -176,11 +176,6 @@ def curl_substitution_required?
       !curl_handles_most_https_certificates? && !HOMEBREW_BREWED_CURL_PATH.exist?
     end
 
-    sig { returns(T::Boolean) }
-    def subversion_handles_most_https_certificates?
-      true
-    end
-
     sig { returns(T::Hash[String, T.nilable(String)]) }
     def build_system_info
       {
diff --git a/Library/Homebrew/env_config.rb b/Library/Homebrew/env_config.rb
index 3ab109a8e7b78..4685dc1c34195 100644
--- a/Library/Homebrew/env_config.rb
+++ b/Library/Homebrew/env_config.rb
@@ -92,12 +92,6 @@ module EnvConfig
         description: "Use this URL as the Homebrew/brew `git`(1) remote.",
         default:     HOMEBREW_BREW_DEFAULT_GIT_REMOTE,
       },
-      HOMEBREW_BREW_WRAPPER:                     {
-        description: "If set, use wrapper to call `brew` rather than auto-detecting it.",
-        # We use backticks to render "Deprecated:" in bold.
-        # TODO: uncomment line below and remove the line above when odeprecated.
-        # description: "`Deprecated:` If set, use wrapper to call `brew` rather than auto-detecting it.",
-      },
       HOMEBREW_BROWSER:                          {
         description:  "Use this as the browser when opening project homepages.",
         default_text: "`$BROWSER` or the OS's default browser.",
@@ -412,10 +406,7 @@ module EnvConfig
         boolean:     true,
       },
       HOMEBREW_NO_FORCE_BREW_WRAPPER:            {
-        description: "If set, disables `$HOMEBREW_FORCE_BREW_WRAPPER` behaviour, even if set.",
-        # We use backticks to render "Deprecated:" in bold.
-        # TODO: uncomment line below and remove the line above when odeprecated.
-        # description: "`Deprecated:` If set, disables `$HOMEBREW_FORCE_BREW_WRAPPER` behaviour, even if set.",
+        description: "`Deprecated:` If set, disables `$HOMEBREW_FORCE_BREW_WRAPPER` behaviour, even if set.",
         boolean:     true,
       },
       HOMEBREW_NO_GITHUB_API:                    {
@@ -580,24 +571,13 @@ def env_method_name(env, hash)
     end
 
     CUSTOM_IMPLEMENTATIONS = T.let(Set.new([
-      :HOMEBREW_BREW_WRAPPER,
       :HOMEBREW_MAKE_JOBS,
-      :HOMEBREW_NO_FORCE_BREW_WRAPPER,
       :HOMEBREW_CASK_OPTS,
       :HOMEBREW_FORBID_PACKAGES_FROM_PATHS,
     ]).freeze, T::Set[Symbol])
 
     FALSY_VALUES = T.let(%w[false no off nil 0].freeze, T::Array[String])
 
-    sig { params(env: String, env_value: T.nilable(String)).void }
-    def check_falsy_values(env, env_value)
-      return unless FALSY_VALUES.include?(env_value&.downcase)
-
-      odisabled "#{env}=#{env_value}", <<~EOS.chomp
-        #{env}=1 to enable and #{env}= (an empty value) to disable
-      EOS
-    end
-
     ENVS.each do |env, hash|
       # Needs a custom implementation.
       next if CUSTOM_IMPLEMENTATIONS.include?(env)
@@ -609,10 +589,7 @@ def check_falsy_values(env, env_value)
         define_method(method_name) do
           env_value = ENV.fetch(env, nil)
 
-          check_falsy_values(env, env_value)
-
-          # TODO: Uncomment the remaining part of the line below after `check_falsy_values` has been removed.
-          env_value.present? # && !FALSY_VALUES.include?(env_value.downcase)
+          env_value.present? && FALSY_VALUES.exclude?(env_value.downcase)
         end
       elsif hash[:default].present?
         define_method(method_name) do
@@ -625,25 +602,6 @@ def check_falsy_values(env, env_value)
       end
     end
 
-    # Needs a custom implementation.
-    sig { returns(T::Boolean) }
-    def no_force_brew_wrapper?
-      # odeprecated "`HOMEBREW_NO_FORCE_BREW_WRAPPER`"
-      env = "HOMEBREW_NO_FORCE_BREW_WRAPPER"
-      env_value = ENV.fetch(env, nil)
-
-      check_falsy_values(env, env_value)
-
-      # TODO: Uncomment the remaining part of the line below after `check_falsy_values` has been removed.
-      env_value.present? # && !FALSY_VALUES.include?(env_value.downcase)
-    end
-
-    sig { returns(T.nilable(String)) }
-    def brew_wrapper
-      # odeprecated "`HOMEBREW_BREW_WRAPPER`"
-      ENV["HOMEBREW_BREW_WRAPPER"].presence
-    end
-
     sig { returns(String) }
     def make_jobs
       jobs = ENV["HOMEBREW_MAKE_JOBS"].to_i
diff --git a/Library/Homebrew/extend/os/mac/development_tools.rb b/Library/Homebrew/extend/os/mac/development_tools.rb
index 3a8793013531e..26483e8ea9749 100644
--- a/Library/Homebrew/extend/os/mac/development_tools.rb
+++ b/Library/Homebrew/extend/os/mac/development_tools.rb
@@ -56,13 +56,6 @@ def curl_handles_most_https_certificates?
           ENV["HOMEBREW_SYSTEM_CURL_TOO_OLD"].nil?
         end
 
-        sig { returns(T::Boolean) }
-        def subversion_handles_most_https_certificates?
-          # The system Subversion is too old for some HTTPS certificates on
-          # older macOS versions.
-          MacOS.version >= :sierra
-        end
-
         sig { returns(String) }
         def installation_instructions
           MacOS::CLT.installation_instructions
diff --git a/Library/Homebrew/extend/os/mac/diagnostic.rb b/Library/Homebrew/extend/os/mac/diagnostic.rb
index 0853742d36efe..f4596cb34e244 100644
--- a/Library/Homebrew/extend/os/mac/diagnostic.rb
+++ b/Library/Homebrew/extend/os/mac/diagnostic.rb
@@ -187,10 +187,6 @@ def check_xcode_up_to_date
           # Homebrew/brew is currently using.
           return if GitHub::Actions.env_set?
 
-          # With fake El Capitan for Portable Ruby, we are intentionally not using Xcode 8.
-          # This is because we are not using the CLT and Xcode 8 has the 10.12 SDK.
-          return if ENV["HOMEBREW_FAKE_MACOS"]
-
           message = <<~EOS
             Your Xcode (#{MacOS::Xcode.version}) is outdated.
             Please update to Xcode #{MacOS::Xcode.latest_version} (or delete it).
diff --git a/Library/Homebrew/extend/os/mac/hardware.rb b/Library/Homebrew/extend/os/mac/hardware.rb
index 38a12686ce899..d2a0e9ed62fd6 100644
--- a/Library/Homebrew/extend/os/mac/hardware.rb
+++ b/Library/Homebrew/extend/os/mac/hardware.rb
@@ -19,7 +19,7 @@ def oldest_cpu(version = nil)
           #   https://github.com/Homebrew/homebrew-core/issues/67713
           elsif version >= :ventura
             :westmere
-          elsif version >= :mojave
+          elsif version >= :catalina
             :nehalem
           else
             super
diff --git a/Library/Homebrew/extend/time.rb b/Library/Homebrew/extend/time.rb
deleted file mode 100644
index cdd9bfcbb9a9c..0000000000000
--- a/Library/Homebrew/extend/time.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-# typed: strong
-# frozen_string_literal: true
-
-require "time"
-require "utils/output"
-
-class Time
-  include Utils::Output::Mixin
-
-  # Backwards compatibility for formulae that used this ActiveSupport extension
-  sig { returns(String) }
-  def rfc3339
-    odisabled "Time#rfc3339", "Time#xmlschema"
-    xmlschema
-  end
-end
diff --git a/Library/Homebrew/formula.rb b/Library/Homebrew/formula.rb
index d95d2e5f224cf..9004c1d41ec77 100644
--- a/Library/Homebrew/formula.rb
+++ b/Library/Homebrew/formula.rb
@@ -1629,7 +1629,7 @@ def link_overwrite?(path)
 
   sig { returns(T::Boolean) }
   def skip_cxxstdlib_check?
-    # odeprecated "`Formula#skip_cxxstdlib_check?`"
+    odeprecated "`Formula#skip_cxxstdlib_check?`"
     false
   end
 
@@ -3705,17 +3705,6 @@ def livecheck_defined?
       @livecheck_defined == true
     end
 
-    # Checks whether a `livecheck` specification is defined or not. This is a
-    # legacy alias for `#livecheck_defined?`.
-    #
-    # It returns `true` when a `livecheck` block is present in the {Formula}
-    # and `false` otherwise.
-    sig { returns(T::Boolean) }
-    def livecheckable?
-      odisabled "`livecheckable?`", "`livecheck_defined?`"
-      @livecheck_defined == true
-    end
-
     # Checks whether a service specification is defined or not.
     #
     # It returns `true` when a service block is present in the {Formula}
@@ -3898,9 +3887,9 @@ def sha256(val) = stable.sha256(val)
     #   root_url "https://example.com" # Optional root to calculate bottle URLs.
     #   rebuild 1 # Marks the old bottle as outdated without bumping the version/revision of the formula.
     #   # Optionally specify the HOMEBREW_CELLAR in which the bottles were built.
-    #   sha256 cellar: "/brew/Cellar", catalina:    "ef65c759c5097a36323fa9c77756468649e8d1980a3a4e05695c05e39568967c"
-    #   sha256 cellar: :any,           mojave:      "28f4090610946a4eb207df102d841de23ced0d06ba31cb79e040d883906dcd4f"
-    #   sha256                         high_sierra: "91dd0caca9bd3f38c439d5a7b6f68440c4274945615fae035ff0a369264b8a2f"
+    #   sha256 cellar: "/brew/Cellar", tahoe:    "ef65c759c5097a36323fa9c77756468649e8d1980a3a4e05695c05e39568967c"
+    #   sha256 cellar: :any,           sequoia:  "28f4090610946a4eb207df102d841de23ced0d06ba31cb79e040d883906dcd4f"
+    #   sha256                         sonoma:   "91dd0caca9bd3f38c439d5a7b6f68440c4274945615fae035ff0a369264b8a2f"
     # end
     # ```
     #
@@ -4108,7 +4097,7 @@ def resource(name, klass = Resource, &block)
     # ```ruby
     # depends_on "sqlite" if MacOS.version >= :catalina
     # depends_on xcode: :build # If the formula really needs full Xcode to compile.
-    # depends_on macos: :mojave # Needs at least macOS Mojave (10.14) to run.
+    # depends_on macos: :sequoia # Needs at least macOS Sequoia (15) to run.
     # ```
     #
     # It is possible to only depend on something if
@@ -4347,7 +4336,7 @@ def keg_only(reason, explanation = "")
     # @api public
     sig { params(check_type: Symbol).void }
     def cxxstdlib_check(check_type)
-      # odeprecated "`cxxstdlib_check :skip`"
+      odeprecated "`cxxstdlib_check :skip`"
       define_method(:skip_cxxstdlib_check?) { true } if check_type == :skip
     end
 
diff --git a/Library/Homebrew/formula_cellar_checks.rb b/Library/Homebrew/formula_cellar_checks.rb
index 70c325172104d..326b9837dc41b 100644
--- a/Library/Homebrew/formula_cellar_checks.rb
+++ b/Library/Homebrew/formula_cellar_checks.rb
@@ -453,11 +453,10 @@ def cpuid_instruction?(file, objdump)
     @instruction_column_index[objdump] ||= begin
       objdump_version = Utils.popen_read(objdump, "--version")
 
-      if (objdump_version.match?(/^Apple LLVM/) && MacOS.version <= :mojave) ||
-         objdump_version.exclude?("LLVM")
-        2 # Mojave `objdump` or GNU Binutils `objdump`
+      if objdump_version.include?("LLVM")
+        1 # `llvm-objdump` or macOS `objdump`
       else
-        1 # `llvm-objdump` or Catalina+ `objdump`
+        2 # GNU Binutils `objdump`
       end
     end
 
diff --git a/Library/Homebrew/keg_relocate.rb b/Library/Homebrew/keg_relocate.rb
index 7a2d9a7e33993..cb01eb8a349e4 100644
--- a/Library/Homebrew/keg_relocate.rb
+++ b/Library/Homebrew/keg_relocate.rb
@@ -342,6 +342,7 @@ def text_files
     # been fixed upstream for some time, but a sufficiently new enough
     # file with that fix is only available in macOS Sierra.
     # https://bugs.gw.com/view.php?id=292
+    # TODO: remove custom logic as we're now not supporting pre-Sierra.
     with_custom_locale("C") do
       files = Set.new path.find.reject { |pn|
         next true if pn.symlink?
diff --git a/Library/Homebrew/language/python.rb b/Library/Homebrew/language/python.rb
index e0e030192bc33..ef098bd5ff4a9 100644
--- a/Library/Homebrew/language/python.rb
+++ b/Library/Homebrew/language/python.rb
@@ -88,7 +88,7 @@ def self.in_sys_path?(python, path)
 
     sig { params(prefix: Pathname, python: T.any(String, Pathname)).returns(T::Array[String]) }
     def self.setup_install_args(prefix, python = "python3")
-      # odeprecated "Language::Python.setup_install_args", "pip and `std_pip_args`"
+      odeprecated "Language::Python.setup_install_args", "pip and `std_pip_args`"
       shim = <<~PYTHON
         import setuptools, tokenize
         __file__ = 'setup.py'
diff --git a/Library/Homebrew/macos_version.rb b/Library/Homebrew/macos_version.rb
index 7dc54c32d99e9..19506bdc1ab7a 100644
--- a/Library/Homebrew/macos_version.rb
+++ b/Library/Homebrew/macos_version.rb
@@ -21,46 +21,17 @@ def initialize(version)
   #       to `DEPRECATED_MACOS_VERSIONS` in `MacOSRequirement`.
   # NOTE: Changes to this list must match `macos_version_name` in `cmd/update.sh`.
   SYMBOLS = T.let({
-    tahoe:       "26",
-    sequoia:     "15",
-    sonoma:      "14",
-    ventura:     "13",
-    monterey:    "12",
-    big_sur:     "11",
-    catalina:    "10.15",
-    # odisabled remove support for Mojave and below 4.7.0
-    mojave:      "10.14",
-    high_sierra: "10.13",
-    sierra:      "10.12",
-    el_capitan:  "10.11",
+    tahoe:    "26",
+    sequoia:  "15",
+    sonoma:   "14",
+    ventura:  "13",
+    monterey: "12",
+    # odisabled: remove support for Big Sur and macOS x86_64 September (or later) 2027
+    big_sur:  "11",
+    # odisabled: remove support for Catalina September (or later) 2026
+    catalina: "10.15",
   }.freeze, T::Hash[Symbol, String])
 
-  # TODO: can be replaced with a call to `#pretty_name` once we remove support
-  # for El Capitan (odisabled in 4.7.0)
-  VERSIONS_TO_ANALYTICS_PRETTY_NAMES = T.let({
-    "26"    => "macOS Tahoe (26)",
-    "15"    => "macOS Sequoia (15)",
-    "14"    => "macOS Sonoma (14)",
-    "13"    => "macOS Ventura (13)",
-    "12"    => "macOS Monterey (12)",
-    "11"    => "macOS Big Sur (11)",
-    "10.16" => "macOS Big Sur (11)",
-    "10.15" => "macOS Catalina (10.15)",
-    "10.14" => "macOS Mojave (10.14)",
-    "10.13" => "macOS High Sierra (10.13)",
-    "10.12" => "macOS Sierra (10.12)",
-    "10.11" => "OS X El Capitan (10.11)",
-  }.freeze, T::Hash[String, String])
-
-  sig { params(version: String).returns(T.nilable(String)) }
-  def self.analytics_pretty_name(version)
-    VERSIONS_TO_ANALYTICS_PRETTY_NAMES.fetch(version) do
-      VERSIONS_TO_ANALYTICS_PRETTY_NAMES.find do |v, _|
-        version.start_with?(v)
-      end&.last
-    end
-  end
-
   sig { params(macos_version: MacOSVersion).returns(Version) }
   def self.kernel_major_version(macos_version)
     version_major = macos_version.major.to_i
diff --git a/Library/Homebrew/os/mac.rb b/Library/Homebrew/os/mac.rb
index cf0058fbea555..d8716478e8498 100644
--- a/Library/Homebrew/os/mac.rb
+++ b/Library/Homebrew/os/mac.rb
@@ -38,12 +38,7 @@ def self.version
     # @api internal
     sig { returns(MacOSVersion) }
     def self.full_version
-      @full_version ||= T.let(nil, T.nilable(MacOSVersion))
-      @full_version ||= if (fake_macos = ENV.fetch("HOMEBREW_FAKE_MACOS", nil)) # for Portable Ruby building
-        MacOSVersion.new(fake_macos)
-      else
-        MacOSVersion.new(VERSION)
-      end
+      @full_version ||= T.let(MacOSVersion.new(VERSION), T.nilable(MacOSVersion))
     end
 
     sig { params(version: String).void }
diff --git a/Library/Homebrew/os/mac/xcode.rb b/Library/Homebrew/os/mac/xcode.rb
index e0edb1fe2134d..5bfefef25bbb2 100644
--- a/Library/Homebrew/os/mac/xcode.rb
+++ b/Library/Homebrew/os/mac/xcode.rb
@@ -76,11 +76,6 @@ def self.latest_sdk_version?
       def self.needs_clt_installed?
         return false if latest_sdk_version?
 
-        # With fake El Capitan for Portable Ruby, we want the full 10.11 SDK so that we can link
-        # against the correct set of libraries in the SDK sysroot rather than the system's copies.
-        # We therefore do not use the CLT under this setup, which installs to /usr/include.
-        return false if ENV["HOMEBREW_FAKE_MACOS"]
-
         without_clt?
       end
 
diff --git a/Library/Homebrew/requirements/macos_requirement.rb b/Library/Homebrew/requirements/macos_requirement.rb
index deddc53698d6d..0ce05a47d9d91 100644
--- a/Library/Homebrew/requirements/macos_requirement.rb
+++ b/Library/Homebrew/requirements/macos_requirement.rb
@@ -9,12 +9,15 @@ class MacOSRequirement < Requirement
 
   attr_reader :comparator, :version
 
-  # TODO: when Yosemite is removed here, keep these around as empty arrays so we
-  #       can keep the deprecation/disabling code the same.
-  DISABLED_MACOS_VERSIONS = [
-    :yosemite,
-  ].freeze
-  DEPRECATED_MACOS_VERSIONS = [].freeze
+  # Keep these around as empty arrays so we can keep the deprecation/disabling code the same.
+  # Treat these like odeprecated/odisabled in terms of deprecation/disabling.
+  DISABLED_MACOS_VERSIONS = T.let([].freeze, T::Array[Symbol])
+  DEPRECATED_MACOS_VERSIONS = T.let([
+    :mojave,
+    :high_sierra,
+    :sierra,
+    :el_capitan,
+  ].freeze, T::Array[Symbol])
 
   def initialize(tags = [], comparator: ">=")
     @version = begin
diff --git a/Library/Homebrew/resource.rb b/Library/Homebrew/resource.rb
index 85de6b51d8ab8..a8cb5c8a89646 100644
--- a/Library/Homebrew/resource.rb
+++ b/Library/Homebrew/resource.rb
@@ -167,17 +167,6 @@ def livecheck_defined?
     @livecheck_defined == true
   end
 
-  # Whether a livecheck specification is defined or not. This is a legacy alias
-  # for `#livecheck_defined?`.
-  #
-  # It returns `true` when a `livecheck` block is present in the {Resource}
-  # and `false` otherwise.
-  sig { returns(T::Boolean) }
-  def livecheckable?
-    odisabled "`livecheckable?`", "`livecheck_defined?`"
-    @livecheck_defined == true
-  end
-
   def sha256(val)
     @checksum = Checksum.new(val)
   end
diff --git a/Library/Homebrew/resource_auditor.rb b/Library/Homebrew/resource_auditor.rb
index 90ccccf93d3fd..84a9d04f0fff6 100644
--- a/Library/Homebrew/resource_auditor.rb
+++ b/Library/Homebrew/resource_auditor.rb
@@ -174,7 +174,6 @@ def audit_urls
           end
           problem "The URL #{url} is not a valid Git URL" unless remote_exists
         elsif strategy <= SubversionDownloadStrategy
-          next unless DevelopmentTools.subversion_handles_most_https_certificates?
           next unless Utils::Svn.available?
 
           problem "The URL #{url} is not a valid SVN URL" unless Utils::Svn.remote_exists? url
diff --git a/Library/Homebrew/rubocops/cask/on_system_conditionals.rb b/Library/Homebrew/rubocops/cask/on_system_conditionals.rb
index 8f59436842dd9..313a7c872cd45 100644
--- a/Library/Homebrew/rubocops/cask/on_system_conditionals.rb
+++ b/Library/Homebrew/rubocops/cask/on_system_conditionals.rb
@@ -14,14 +14,14 @@ module Cask
       # ```ruby
       # # bad
       # cask 'foo' do
-      #   if MacOS.version == :high_sierra
+      #   if MacOS.version == :tahoe
       #     sha256 "..."
       #   end
       # end
       #
       # # good
       # cask 'foo' do
-      #   on_high_sierra do
+      #   on_tahoe do
       #     sha256 "..."
       #   end
       # end
diff --git a/Library/Homebrew/shims/shared/git b/Library/Homebrew/shims/shared/git
index 9c1e61a57a3e3..c45dd12c6ad8b 100755
--- a/Library/Homebrew/shims/shared/git
+++ b/Library/Homebrew/shims/shared/git
@@ -46,10 +46,7 @@ then
   xcode_path="$(/usr/bin/xcode-select -print-path 2>/dev/null)"
   if [[ -z "${xcode_path}" ]]
   then
-    if [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -ge "100900" ]]
-    then
-      popup_stub=1
-    fi
+    popup_stub=1
   fi
   if [[ -z "${popup_stub}" && "${xcode_path}" != "/" ]]
   then
@@ -61,11 +58,5 @@ fi
 path="/Applications/Xcode.app/Contents/Developer/usr/bin/${SHIM_FILE}"
 safe_exec "${path}" "$@"
 
-if [[ -z "${popup_stub}" && "${HOMEBREW_MACOS_VERSION_NUMERIC}" -lt "101500" ]]
-then
-  path="/usr/bin/${SHIM_FILE}"
-  safe_exec "${path}" "$@"
-fi
-
 echo "You must: brew install ${SHIM_FILE}" >&2
 exit 1
diff --git a/Library/Homebrew/shims/super/cc b/Library/Homebrew/shims/super/cc
index cfbb46e36623c..ae02176b8aac1 100755
--- a/Library/Homebrew/shims/super/cc
+++ b/Library/Homebrew/shims/super/cc
@@ -24,10 +24,6 @@ def mac?
   RUBY_PLATFORM[/darwin/]
 end
 
-def high_sierra_or_later?
-  mac? && ENV["HOMEBREW_MACOS_VERSION_NUMERIC"].to_s.to_i >= 101300
-end
-
 def linux?
   RUBY_PLATFORM[/linux/]
 end
@@ -216,7 +212,7 @@ class Cmd
       # used for -Xpreprocessor -fopenmp
       args << arg << enum.next
     when /-mmacosx-version-min=(\d+)\.(\d+)/
-      if high_sierra_or_later? && Regexp.last_match(1) == "10" && Regexp.last_match(2).to_i < 9
+      if Regexp.last_match(1) == "10" && Regexp.last_match(2).to_i < 9
         arg = "-mmacosx-version-min=10.9"
       end
       args << arg
diff --git a/Library/Homebrew/sorbet/rbi/dsl/cask/cask.rbi b/Library/Homebrew/sorbet/rbi/dsl/cask/cask.rbi
index 1d831fddd16de..03de5428ff7e5 100644
--- a/Library/Homebrew/sorbet/rbi/dsl/cask/cask.rbi
+++ b/Library/Homebrew/sorbet/rbi/dsl/cask/cask.rbi
@@ -126,9 +126,6 @@ class Cask::Cask
   sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
   def livecheck_defined?(*args, &block); end
 
-  sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
-  def livecheckable?(*args, &block); end
-
   sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
   def manpage(*args, &block); end
 
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/bundle.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/bundle.rbi
index 41e89bef65bdd..841fccf1d2a2b 100644
--- a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/bundle.rbi
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/bundle.rbi
@@ -89,9 +89,6 @@ class Homebrew::Cmd::Bundle::Args < Homebrew::CLI::Args
   sig { returns(T::Boolean) }
   def vscode?; end
 
-  sig { returns(T::Boolean) }
-  def whalebrew?; end
-
   sig { returns(T::Boolean) }
   def zap?; end
 end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cask/ast/stanza.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cask/ast/stanza.rbi
index 732b357147699..41aa15fa4f919 100644
--- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cask/ast/stanza.rbi
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cask/ast/stanza.rbi
@@ -102,27 +102,15 @@ class RuboCop::Cask::AST::Stanza
   sig { returns(T::Boolean) }
   def on_catalina?; end
 
-  sig { returns(T::Boolean) }
-  def on_el_capitan?; end
-
-  sig { returns(T::Boolean) }
-  def on_high_sierra?; end
-
   sig { returns(T::Boolean) }
   def on_intel?; end
 
-  sig { returns(T::Boolean) }
-  def on_mojave?; end
-
   sig { returns(T::Boolean) }
   def on_monterey?; end
 
   sig { returns(T::Boolean) }
   def on_sequoia?; end
 
-  sig { returns(T::Boolean) }
-  def on_sierra?; end
-
   sig { returns(T::Boolean) }
   def on_sonoma?; end
 
diff --git a/Library/Homebrew/startup/config.rb b/Library/Homebrew/startup/config.rb
index 6c74b5c9f5025..6dcdc4392d25c 100644
--- a/Library/Homebrew/startup/config.rb
+++ b/Library/Homebrew/startup/config.rb
@@ -4,9 +4,8 @@
 raise "HOMEBREW_BREW_FILE was not exported! Please call bin/brew directly!" unless ENV["HOMEBREW_BREW_FILE"]
 
 # The path to the executable that should be used to run `brew`.
-# This may be HOMEBREW_ORIGINAL_BREW_FILE or HOMEBREW_BREW_WRAPPER depending on
-# the system configuration. Favour this instead of running `brew` and expecting
-# it to be in the `PATH`.
+# This may be HOMEBREW_ORIGINAL_BREW_FILE depending on the system configuration.
+# Favour this instead of running `brew` and expecting it to be in the `PATH`.
 # @api public
 HOMEBREW_BREW_FILE = Pathname(ENV.fetch("HOMEBREW_BREW_FILE")).freeze
 
diff --git a/Library/Homebrew/test/bottle_specification_spec.rb b/Library/Homebrew/test/bottle_specification_spec.rb
index 5c1888f7c2de9..8c6128b03a241 100644
--- a/Library/Homebrew/test/bottle_specification_spec.rb
+++ b/Library/Homebrew/test/bottle_specification_spec.rb
@@ -8,10 +8,10 @@
   describe "#sha256" do
     it "works without cellar" do
       checksums = {
-        arm64_big_sur: "deadbeef" * 8,
-        big_sur:       "faceb00c" * 8,
-        catalina:      "baadf00d" * 8,
-        mojave:        "8badf00d" * 8,
+        arm64_tahoe: "deadbeef" * 8,
+        tahoe:       "faceb00c" * 8,
+        sequoia:     "baadf00d" * 8,
+        sonoma:      "8badf00d" * 8,
       }
 
       checksums.each_pair do |cat, digest|
@@ -23,10 +23,10 @@
 
     it "works with cellar" do
       checksums = [
-        { cellar: :any_skip_relocation, tag: :arm64_big_sur, digest: "deadbeef" * 8 },
-        { cellar: :any, tag: :big_sur, digest: "faceb00c" * 8 },
-        { cellar: "/usr/local/Cellar", tag: :catalina, digest: "baadf00d" * 8 },
-        { cellar: Homebrew::DEFAULT_CELLAR, tag: :mojave, digest: "8badf00d" * 8 },
+        { cellar: :any_skip_relocation, tag: :arm64_tahoe, digest: "deadbeef" * 8 },
+        { cellar: :any, tag: :tahoe, digest: "faceb00c" * 8 },
+        { cellar: "/usr/local/Cellar", tag: :sequoia, digest: "baadf00d" * 8 },
+        { cellar: Homebrew::DEFAULT_CELLAR, tag: :sonoma, digest: "8badf00d" * 8 },
       ]
 
       checksums.each do |checksum|
diff --git a/Library/Homebrew/test/bundle/commands/dump_spec.rb b/Library/Homebrew/test/bundle/commands/dump_spec.rb
index 0868e6021eb29..8ac61bf089040 100644
--- a/Library/Homebrew/test/bundle/commands/dump_spec.rb
+++ b/Library/Homebrew/test/bundle/commands/dump_spec.rb
@@ -5,13 +5,12 @@
 require "bundle/cask_dumper"
 require "bundle/formula_dumper"
 require "bundle/tap_dumper"
-require "bundle/whalebrew_dumper"
 require "bundle/vscode_extension_dumper"
 
 RSpec.describe Homebrew::Bundle::Commands::Dump do
   subject(:dump) do
     described_class.run(global:, file: nil, describe: false, force:, no_restart: false, taps: true, formulae: true,
-                        casks: true, mas: true, whalebrew: true, vscode: true, go: true)
+                        casks: true, mas: true, vscode: true, go: true)
   end
 
   let(:force) { false }
@@ -21,7 +20,6 @@
     Homebrew::Bundle::CaskDumper.reset!
     Homebrew::Bundle::FormulaDumper.reset!
     Homebrew::Bundle::TapDumper.reset!
-    Homebrew::Bundle::WhalebrewDumper.reset!
     Homebrew::Bundle::VscodeExtensionDumper.reset!
   end
 
@@ -41,7 +39,6 @@
       expect(Homebrew::Bundle::TapDumper).not_to receive(:dump)
       expect(Homebrew::Bundle::FormulaDumper).not_to receive(:dump)
       expect(Homebrew::Bundle::CaskDumper).not_to receive(:dump)
-      expect(Homebrew::Bundle::WhalebrewDumper).not_to receive(:dump)
       expect do
         dump
       end.to raise_error(RuntimeError)
@@ -62,7 +59,6 @@
       allow(DevelopmentTools).to receive_messages(needs_libc_formula?: false, needs_compiler_formula?: false)
 
       stub_formula_loader formula("mas") { url "mas-1.0" }
-      stub_formula_loader formula("whalebrew") { url "whalebrew-1.0" }
     end
 
     it "doesn't raise error" do
diff --git a/Library/Homebrew/test/bundle/commands/list_spec.rb b/Library/Homebrew/test/bundle/commands/list_spec.rb
index 2626babc92ece..5e6e662c8d49e 100644
--- a/Library/Homebrew/test/bundle/commands/list_spec.rb
+++ b/Library/Homebrew/test/bundle/commands/list_spec.rb
@@ -5,14 +5,13 @@
 
 RSpec.describe Homebrew::Bundle::Commands::List do
   subject(:list) do
-    described_class.run(global: false, file: nil, formulae:, casks:, taps:, mas:, whalebrew:, vscode:, go:)
+    described_class.run(global: false, file: nil, formulae:, casks:, taps:, mas:, vscode:, go:)
   end
 
   let(:formulae) { true }
   let(:casks) { false }
   let(:taps) { false }
   let(:mas) { false }
-  let(:whalebrew) { false }
   let(:vscode) { false }
   let(:go) { false }
 
@@ -28,7 +27,6 @@
           brew 'mysql', conflicts_with: ['mysql56']
           cask 'google-chrome'
           mas '1Password', id: 443987910
-          whalebrew 'whalebrew/imagemagick'
           vscode 'shopify.ruby-lsp'
           go 'github.com/charmbracelet/crush'
         EOS
@@ -41,13 +39,12 @@
 
     describe "limiting when certain options are passed" do
       types_and_deps = {
-        taps:      "phinze/cask",
-        formulae:  "mysql",
-        casks:     "google-chrome",
-        mas:       "1Password",
-        whalebrew: "whalebrew/imagemagick",
-        vscode:    "shopify.ruby-lsp",
-        go:        "github.com/charmbracelet/crush",
+        taps:     "phinze/cask",
+        formulae: "mysql",
+        casks:    "google-chrome",
+        mas:      "1Password",
+        vscode:   "shopify.ruby-lsp",
+        go:       "github.com/charmbracelet/crush",
       }
 
       combinations = 1.upto(types_and_deps.length).flat_map do |i|
@@ -65,7 +62,6 @@
           let(:casks) { args_hash.fetch(:casks, false) }
           let(:taps) { args_hash.fetch(:taps, false) }
           let(:mas) { args_hash.fetch(:mas, false) }
-          let(:whalebrew) { args_hash.fetch(:whalebrew, false) }
           let(:vscode) { args_hash.fetch(:vscode, false) }
           let(:go) { args_hash.fetch(:go, false) }
 
diff --git a/Library/Homebrew/test/bundle/dsl_spec.rb b/Library/Homebrew/test/bundle/dsl_spec.rb
index 7d3a715053e8f..5e38f6ab93dfe 100644
--- a/Library/Homebrew/test/bundle/dsl_spec.rb
+++ b/Library/Homebrew/test/bundle/dsl_spec.rb
@@ -23,7 +23,6 @@ def dsl_from_string(string)
         cask 'java' unless system '/usr/libexec/java_home --failfast'
         cask 'firefox', args: { appdir: '~/my-apps/Applications' }
         mas '1Password', id: 443987910
-        whalebrew 'whalebrew/wget'
         vscode 'GitHub.codespaces'
         go 'github.com/charmbracelet/crush'
       EOS
@@ -53,9 +52,8 @@ def dsl_from_string(string)
       expect(dsl.entries[8].options).to eql(args: { appdir: "~/my-apps/Applications" }, full_name: "firefox")
       expect(dsl.entries[9].name).to eql("1Password")
       expect(dsl.entries[9].options).to eql(id: 443_987_910)
-      expect(dsl.entries[10].name).to eql("whalebrew/wget")
-      expect(dsl.entries[11].name).to eql("GitHub.codespaces")
-      expect(dsl.entries[12].name).to eql("github.com/charmbracelet/crush")
+      expect(dsl.entries[10].name).to eql("GitHub.codespaces")
+      expect(dsl.entries[11].name).to eql("github.com/charmbracelet/crush")
     end
   end
 
diff --git a/Library/Homebrew/test/bundle/dumper_spec.rb b/Library/Homebrew/test/bundle/dumper_spec.rb
index 3d5713f48c132..11c97f8c5f76f 100644
--- a/Library/Homebrew/test/bundle/dumper_spec.rb
+++ b/Library/Homebrew/test/bundle/dumper_spec.rb
@@ -6,9 +6,9 @@
 require "bundle/tap_dumper"
 require "bundle/cask_dumper"
 require "bundle/mac_app_store_dumper"
-require "bundle/whalebrew_dumper"
 require "bundle/vscode_extension_dumper"
 require "bundle/brew_services"
+require "bundle/go_dumper"
 require "cask"
 
 RSpec.describe Homebrew::Bundle::Dumper do
@@ -18,15 +18,11 @@
     ENV["HOMEBREW_BUNDLE_FILE"] = ""
 
     allow(Homebrew::Bundle).to \
-      receive_messages(
-        cask_installed?: true, mas_installed?: false, whalebrew_installed?: false,
-        vscode_installed?: false
-      )
+      receive_messages(cask_installed?: true, mas_installed?: false, vscode_installed?: false)
     Homebrew::Bundle::FormulaDumper.reset!
     Homebrew::Bundle::TapDumper.reset!
     Homebrew::Bundle::CaskDumper.reset!
     Homebrew::Bundle::MacAppStoreDumper.reset!
-    Homebrew::Bundle::WhalebrewDumper.reset!
     Homebrew::Bundle::VscodeExtensionDumper.reset!
     Homebrew::Bundle::BrewServices.reset!
 
@@ -44,13 +40,14 @@
                                  config:    nil)
 
     allow(Cask::Caskroom).to receive(:casks).and_return([chrome, java, iterm2beta])
+    allow(Homebrew::Bundle::GoDumper).to receive(:`).and_return("")
     allow(Tap).to receive(:select).and_return([])
   end
 
   it "generates output" do
     expect(dumper.build_brewfile(
              describe: false, no_restart: false, formulae: true, taps: true, casks: true, mas: true,
-             whalebrew: true, vscode: true, go: true
+             vscode: true, go: true
            )).to eql("cask \"google-chrome\"\ncask \"java\"\ncask \"iterm2-beta\"\n")
   end
 
diff --git a/Library/Homebrew/test/bundle/skipper_spec.rb b/Library/Homebrew/test/bundle/skipper_spec.rb
index 379d0aadb0f66..06d3ab205626c 100644
--- a/Library/Homebrew/test/bundle/skipper_spec.rb
+++ b/Library/Homebrew/test/bundle/skipper_spec.rb
@@ -11,7 +11,6 @@
   before do
     allow(ENV).to receive(:[]).and_return(nil)
     allow(ENV).to receive(:[]).with("HOMEBREW_BUNDLE_BREW_SKIP").and_return("mysql")
-    allow(ENV).to receive(:[]).with("HOMEBREW_BUNDLE_WHALEBREW_SKIP").and_return("whalebrew/imagemagick")
     allow(ENV).to receive(:[]).with("HOMEBREW_BUNDLE_TAP_SKIP").and_return("org/repo")
     allow(Formatter).to receive(:warning)
     skipper.instance_variable_set(:@skipped_entries, nil)
@@ -47,14 +46,6 @@
       end
     end
 
-    context "with a listed whalebrew image" do
-      let(:entry) { Homebrew::Bundle::Dsl::Entry.new(:whalebrew, "whalebrew/imagemagick") }
-
-      it "returns true" do
-        expect(skipper.skip?(entry)).to be true
-      end
-    end
-
     context "with a listed formula in a failed tap" do
       let(:entry) { Homebrew::Bundle::Dsl::Entry.new(:brew, "org/repo/formula") }
 
diff --git a/Library/Homebrew/test/bundle/whalebrew_dumper_spec.rb b/Library/Homebrew/test/bundle/whalebrew_dumper_spec.rb
deleted file mode 100644
index 2ec51ebc54730..0000000000000
--- a/Library/Homebrew/test/bundle/whalebrew_dumper_spec.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require "bundle"
-require "bundle/whalebrew_dumper"
-
-RSpec.describe Homebrew::Bundle::WhalebrewDumper do
-  subject(:dumper) { described_class }
-
-  context "when whalebrew is not installed" do
-    before do
-      dumper.reset!
-      allow(Homebrew::Bundle).to receive(:whalebrew_installed?).and_return(false)
-    end
-
-    it "returns empty list" do
-      expect(dumper.images).to be_empty
-    end
-
-    it "dumps as empty string" do
-      expect(dumper.dump).to eql("")
-    end
-  end
-
-  context "when whalebrew is installed" do
-    before do
-      allow(Homebrew::Bundle).to receive(:whalebrew_installed?).and_return(true)
-      allow(dumper).to receive(:images).and_return(["whalebrew/wget", "whalebrew/dig"])
-    end
-
-    context "when images are installed" do
-      let(:expected_whalebrew_dump) do
-        %Q(whalebrew "whalebrew/wget"\nwhalebrew "whalebrew/dig")
-      end
-
-      it "returns correct listing" do
-        expect(dumper.images).to eq(["whalebrew/wget", "whalebrew/dig"])
-      end
-
-      it "dumps usable output for Brewfile" do
-        expect(dumper.dump).to eql(expected_whalebrew_dump)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/test/bundle/whalebrew_installer_spec.rb b/Library/Homebrew/test/bundle/whalebrew_installer_spec.rb
deleted file mode 100644
index b1444cfeb572b..0000000000000
--- a/Library/Homebrew/test/bundle/whalebrew_installer_spec.rb
+++ /dev/null
@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require "bundle"
-require "bundle/whalebrew_installer"
-require "bundle/whalebrew_dumper"
-
-RSpec.describe Homebrew::Bundle::WhalebrewInstaller do
-  before do
-    stub_formula_loader formula("whalebrew") { url "whalebrew-1.0" }
-  end
-
-  describe ".installed_images" do
-    before do
-      described_class.reset!
-      Homebrew::Bundle::WhalebrewDumper.reset!
-    end
-
-    it "shells out" do
-      expect { described_class.installed_images }.not_to raise_error
-    end
-  end
-
-  describe ".image_installed?" do
-    context "when an image is already installed" do
-      before do
-        described_class.reset!
-      end
-
-      it "returns true" do
-        allow(Homebrew::Bundle::WhalebrewDumper).to receive(:images).and_return(["whalebrew/wget"])
-        expect(described_class.image_installed?("whalebrew/wget")).to be(true)
-      end
-    end
-  end
-
-  context "when whalebrew isn't installed" do
-    before do
-      allow(Homebrew::Bundle).to receive(:whalebrew_installed?).and_return(false)
-    end
-
-    it "successfully installs whalebrew" do
-      expect(Homebrew::Bundle).to receive(:system).with(HOMEBREW_BREW_FILE, "install", "--formula", "whalebrew",
-                                                        verbose: false)
-                                                  .and_return(true)
-      expect { described_class.preinstall!("whalebrew/wget") }.to raise_error(RuntimeError)
-    end
-  end
-
-  context "when whalebrew is installed" do
-    before do
-      described_class.reset!
-      Homebrew::Bundle::WhalebrewDumper.reset!
-      allow(Homebrew::Bundle).to receive(:whalebrew_installed?).and_return(true)
-      allow(Homebrew::Bundle).to receive(:system).with("whalebrew", "install", "whalebrew/wget", verbose: false)
-                                                 .and_return(true)
-    end
-
-    context "when the requested image is already installed" do
-      before do
-        allow(described_class).to receive(:image_installed?).with("whalebrew/wget").and_return(true)
-      end
-
-      it "skips" do
-        expect(described_class.preinstall!("whalebrew/wget")).to be(false)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/test/cask/cask_spec.rb b/Library/Homebrew/test/cask/cask_spec.rb
index e5d2e4499ce50..2e06f41d77bfc 100644
--- a/Library/Homebrew/test/cask/cask_spec.rb
+++ b/Library/Homebrew/test/cask/cask_spec.rb
@@ -304,7 +304,7 @@
 
     context "when loaded from cask file" do
       it "returns expected hash" do
-        allow(MacOS).to receive(:version).and_return(MacOSVersion.new("13"))
+        allow(MacOS).to receive(:version).and_return(MacOSVersion.new("14"))
 
         cask = Cask::CaskLoader.load("everything")
 
diff --git a/Library/Homebrew/test/cask/dsl/caveats_spec.rb b/Library/Homebrew/test/cask/dsl/caveats_spec.rb
index 762088517a426..3015935b5a4bb 100644
--- a/Library/Homebrew/test/cask/dsl/caveats_spec.rb
+++ b/Library/Homebrew/test/cask/dsl/caveats_spec.rb
@@ -15,16 +15,16 @@
   describe "#kext" do
     let(:cask) { instance_double(Cask::Cask) }
 
-    it "points to System Preferences on macOS Monterey and earlier" do
-      allow(MacOS).to receive(:version).and_return(MacOSVersion.new("12"))
+    it "returns System Settings on macOS Ventura or later" do
+      allow(MacOS).to receive(:version).and_return(MacOSVersion.from_symbol(:ventura))
       caveats.eval_caveats do
         kext
       end
-      expect(caveats.to_s).to include("System Preferences → Security & Privacy → General")
+      expect(caveats.to_s).to be_empty
     end
 
-    it "points to System Settings on macOS Ventura and later" do
-      allow(MacOS).to receive(:version).and_return(MacOSVersion.new("13"))
+    it "returns System Preferences on macOS Sonoma and earlier" do
+      allow(MacOS).to receive(:version).and_return(MacOSVersion.from_symbol(:sonoma))
       caveats.eval_caveats do
         kext
       end
diff --git a/Library/Homebrew/test/cask/dsl_spec.rb b/Library/Homebrew/test/cask/dsl_spec.rb
index c53c7419e8bfc..374f47176d2a8 100644
--- a/Library/Homebrew/test/cask/dsl_spec.rb
+++ b/Library/Homebrew/test/cask/dsl_spec.rb
@@ -500,11 +500,11 @@ def caveats
       end
     end
 
-    context "with deprecated conflicts_with key" do
-      let(:token) { "conflicts-with-deprecated-key" }
+    context "with disabled conflicts_with key" do
+      let(:token) { "conflicts-with-disabled-key" }
 
-      it "loads but shows deprecation warning for deprecated key" do
-        expect { cask.conflicts_with }.to raise_error(Cask::CaskInvalidError, /is deprecated/)
+      it "loads but shows disabled warning for disabled key" do
+        expect { cask.conflicts_with }.to raise_error(Cask::CaskInvalidError, /is disabled/)
       end
     end
   end
diff --git a/Library/Homebrew/test/cask_dependent_spec.rb b/Library/Homebrew/test/cask_dependent_spec.rb
index 38e9da163fc03..e6bd028110034 100644
--- a/Library/Homebrew/test/cask_dependent_spec.rb
+++ b/Library/Homebrew/test/cask_dependent_spec.rb
@@ -11,7 +11,7 @@
       cask "testing" do
         depends_on formula: "baz"
         depends_on cask: "foo-cask"
-        depends_on macos: ">= :mojave"
+        depends_on macos: ">= :sequoia"
       end
     RUBY
   end
diff --git a/Library/Homebrew/test/dev-cmd/bottle_spec.rb b/Library/Homebrew/test/dev-cmd/bottle_spec.rb
index 5b76df2bc2631..84fd20938add2 100644
--- a/Library/Homebrew/test/dev-cmd/bottle_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/bottle_spec.rb
@@ -242,7 +242,7 @@ def install
         setup_test_formula "testball", bottle_block: <<~EOS
 
           bottle do
-            sha256 cellar: :any, high_sierra: "6971b6eebf4c00eaaed72a1104a49be63861eabc95d679a0c84040398e320059"
+            sha256 cellar: :any, sonoma: "6971b6eebf4c00eaaed72a1104a49be63861eabc95d679a0c84040398e320059"
           end
         EOS
         system "git", "add", "--all"
@@ -263,9 +263,9 @@ def install
         ==> testball
           bottle do
             sha256 cellar: :any_skip_relocation, arm64_big_sur: "8f9aecd233463da6a4ea55f5f88fc5841718c013f3e2a7941350d6130f1dc149"
+            sha256 cellar: :any,                 sonoma:        "6971b6eebf4c00eaaed72a1104a49be63861eabc95d679a0c84040398e320059"
             sha256 cellar: :any_skip_relocation, big_sur:       "a0af7dcbb5c83f6f3f7ecd507c2d352c1a018f894d51ad241ce8492fa598010f"
             sha256 cellar: :any_skip_relocation, catalina:      "5334dd344986e46b2aa4f0471cac7b0914bd7de7cb890a34415771788d03f2ac"
-            sha256 cellar: :any,                 high_sierra:   "6971b6eebf4c00eaaed72a1104a49be63861eabc95d679a0c84040398e320059"
           end
         \[master [0-9a-f]{4,40}\] testball: update 1\.0 bottle\.
          1 file changed, 4 insertions\(\+\), 1 deletion\(\-\)
@@ -285,9 +285,9 @@ class Testball < Formula
 
           bottle do
             sha256 cellar: :any_skip_relocation, arm64_big_sur: "8f9aecd233463da6a4ea55f5f88fc5841718c013f3e2a7941350d6130f1dc149"
+            sha256 cellar: :any,                 sonoma:        "6971b6eebf4c00eaaed72a1104a49be63861eabc95d679a0c84040398e320059"
             sha256 cellar: :any_skip_relocation, big_sur:       "a0af7dcbb5c83f6f3f7ecd507c2d352c1a018f894d51ad241ce8492fa598010f"
             sha256 cellar: :any_skip_relocation, catalina:      "5334dd344986e46b2aa4f0471cac7b0914bd7de7cb890a34415771788d03f2ac"
-            sha256 cellar: :any,                 high_sierra:   "6971b6eebf4c00eaaed72a1104a49be63861eabc95d679a0c84040398e320059"
           end
 
           def install
@@ -448,15 +448,15 @@ def install
 
       it "checks for conflicting checksums" do
         old_spec = BottleSpecification.new
-        old_catalina_sha256 = "109c0cb581a7b5d84da36d84b221fb9dd0f8a927b3044d82611791c9907e202e"
-        old_spec.sha256(catalina: old_catalina_sha256)
-        old_spec.sha256(mojave: "7571772bf7a0c9fe193e70e521318b53993bee6f351976c9b6e01e00d13d6c3f")
-        new_catalina_sha256 = "ec6d7f08412468f28dee2be17ad8cd8b883b16b34329efcecce019b8c9736428"
-        new_hash = { "tags" => { "catalina" => { "sha256" => new_catalina_sha256 } } }
-        expected_checksum_hash = { mojave: "7571772bf7a0c9fe193e70e521318b53993bee6f351976c9b6e01e00d13d6c3f" }
+        old_sequoia_sha256 = "109c0cb581a7b5d84da36d84b221fb9dd0f8a927b3044d82611791c9907e202e"
+        old_spec.sha256(sequoia: old_sequoia_sha256)
+        old_spec.sha256(sonoma: "7571772bf7a0c9fe193e70e521318b53993bee6f351976c9b6e01e00d13d6c3f")
+        new_sequoia_sha256 = "ec6d7f08412468f28dee2be17ad8cd8b883b16b34329efcecce019b8c9736428"
+        new_hash = { "tags" => { "sequoia" => { "sha256" => new_sequoia_sha256 } } }
+        expected_checksum_hash = { sonoma: "7571772bf7a0c9fe193e70e521318b53993bee6f351976c9b6e01e00d13d6c3f" }
         expected_checksum_hash[:cellar] = Homebrew::DEFAULT_MACOS_CELLAR
         expect(homebrew.merge_bottle_spec([:sha256], old_spec, new_hash)).to eq [
-          ["sha256 catalina: old: #{old_catalina_sha256.inspect}, new: #{new_catalina_sha256.inspect}"],
+          ["sha256 sequoia: old: #{old_sequoia_sha256.inspect}, new: #{new_sequoia_sha256.inspect}"],
           [expected_checksum_hash],
         ]
       end
@@ -464,66 +464,66 @@ def install
 
     describe "::generate_sha256_line" do
       it "generates a string without cellar" do
-        expect(homebrew.generate_sha256_line(:catalina, "deadbeef", nil, 0, 10)).to eq(
+        expect(homebrew.generate_sha256_line(:sequoia, "deadbeef", nil, 0, 10)).to eq(
           <<~RUBY.chomp,
-            sha256 catalina: "deadbeef"
+            sha256 sequoia:  "deadbeef"
           RUBY
         )
       end
 
       it "generates a string with cellar symbol" do
-        expect(homebrew.generate_sha256_line(:catalina, "deadbeef", :any, 14, 24)).to eq(
+        expect(homebrew.generate_sha256_line(:sequoia, "deadbeef", :any, 14, 24)).to eq(
           <<~RUBY.chomp,
-            sha256 cellar: :any, catalina: "deadbeef"
+            sha256 cellar: :any, sequoia:  "deadbeef"
           RUBY
         )
       end
 
       it "generates a string with default cellar path" do
-        expect(homebrew.generate_sha256_line(:catalina, "deadbeef", Homebrew::DEFAULT_LINUX_CELLAR, 0, 10)).to eq(
+        expect(homebrew.generate_sha256_line(:sequoia, "deadbeef", Homebrew::DEFAULT_LINUX_CELLAR, 0, 10)).to eq(
           <<~RUBY.chomp,
-            sha256 catalina: "deadbeef"
+            sha256 sequoia:  "deadbeef"
           RUBY
         )
       end
 
       it "generates a string with non-default cellar path" do
-        expect(homebrew.generate_sha256_line(:catalina, "deadbeef", "/home/test", 22, 32)).to eq(
+        expect(homebrew.generate_sha256_line(:sequoia, "deadbeef", "/home/test", 22, 32)).to eq(
           <<~RUBY.chomp,
-            sha256 cellar: "/home/test", catalina: "deadbeef"
+            sha256 cellar: "/home/test", sequoia:  "deadbeef"
           RUBY
         )
       end
 
       context "with offsets" do
         it "generates a string without cellar" do
-          expect(homebrew.generate_sha256_line(:catalina, "deadbeef", nil, 0, 15)).to eq(
+          expect(homebrew.generate_sha256_line(:sequoia, "deadbeef", nil, 0, 15)).to eq(
             <<~RUBY.chomp,
-              sha256 catalina:      "deadbeef"
+              sha256 sequoia:       "deadbeef"
             RUBY
           )
         end
 
         it "generates a string with cellar symbol" do
-          expect(homebrew.generate_sha256_line(:catalina, "deadbeef", :any, 20, 35)).to eq(
+          expect(homebrew.generate_sha256_line(:sequoia, "deadbeef", :any, 20, 35)).to eq(
             <<~RUBY.chomp,
-              sha256 cellar: :any,       catalina:      "deadbeef"
+              sha256 cellar: :any,       sequoia:       "deadbeef"
             RUBY
           )
         end
 
         it "generates a string with default cellar path" do
-          expect(homebrew.generate_sha256_line(:catalina, "deadbeef", Homebrew::DEFAULT_LINUX_CELLAR, 14, 30)).to eq(
+          expect(homebrew.generate_sha256_line(:sequoia, "deadbeef", Homebrew::DEFAULT_LINUX_CELLAR, 14, 30)).to eq(
             <<~RUBY.chomp,
-              sha256               catalina:       "deadbeef"
+              sha256               sequoia:        "deadbeef"
             RUBY
           )
         end
 
         it "generates a string with non-default cellar path" do
-          expect(homebrew.generate_sha256_line(:catalina, "deadbeef", "/home/test", 25, 36)).to eq(
+          expect(homebrew.generate_sha256_line(:sequoia, "deadbeef", "/home/test", 25, 36)).to eq(
             <<~RUBY.chomp,
-              sha256 cellar: "/home/test",    catalina:  "deadbeef"
+              sha256 cellar: "/home/test",    sequoia:   "deadbeef"
             RUBY
           )
         end
diff --git a/Library/Homebrew/test/formula_spec.rb b/Library/Homebrew/test/formula_spec.rb
index 4cb8e1c11a74c..9be90885fd3fb 100644
--- a/Library/Homebrew/test/formula_spec.rb
+++ b/Library/Homebrew/test/formula_spec.rb
@@ -991,12 +991,12 @@ class FooVariations < Formula
             depends_on "intel-formula"
           end
 
-          on_big_sur do
-            depends_on "big-sur-formula"
+          on_sequoia do
+            depends_on "sequoia-formula"
           end
 
-          on_catalina :or_older do
-            depends_on "catalina-or-older-formula"
+          on_sonoma :or_older do
+            depends_on "sonoma-or-older-formula"
           end
 
           on_linux do
@@ -1008,32 +1008,35 @@ class FooVariations < Formula
     let(:expected_variations) do
       <<~JSON
         {
-          "monterey": {
+          "tahoe": {
             "dependencies": [
               "intel-formula"
             ]
           },
-          "big_sur": {
+          "arm64_tahoe": {
+            "dependencies": []
+          },
+          "sequoia": {
             "dependencies": [
               "intel-formula",
-              "big-sur-formula"
+              "sequoia-formula"
             ]
           },
-          "arm64_big_sur": {
+          "arm64_sequoia": {
             "dependencies": [
-              "big-sur-formula"
+              "sequoia-formula"
             ]
           },
-          "catalina": {
+          "sonoma": {
             "dependencies": [
               "intel-formula",
-              "catalina-or-older-formula"
+              "sonoma-or-older-formula"
             ]
           },
-          "mojave": {
+          "ventura": {
             "dependencies": [
               "intel-formula",
-              "catalina-or-older-formula"
+              "sonoma-or-older-formula"
             ]
           },
           "x86_64_linux": {
@@ -1053,7 +1056,7 @@ class FooVariations < Formula
 
     before do
       # Use a more limited os list to shorten the variations hash
-      os_list = [:monterey, :big_sur, :catalina, :mojave, :linux]
+      os_list = [:tahoe, :sequoia, :sonoma, :ventura, :linux]
       valid_tags = os_list.product(OnSystem::ARCH_OPTIONS).filter_map do |os, arch|
         tag = Utils::Bottles::Tag.new(system: os, arch:)
         next unless tag.valid_combination?
@@ -1062,7 +1065,7 @@ class FooVariations < Formula
       end
       stub_const("OnSystem::VALID_OS_ARCH_TAGS", valid_tags)
 
-      # For consistency, always run on Monterey and ARM
+      # For consistency, always run on Tahoe and ARM
       allow(MacOS).to receive(:version).and_return(MacOSVersion.new("12"))
       allow(Hardware::CPU).to receive(:type).and_return(:arm)
 
@@ -1764,18 +1767,18 @@ def install
         def install
           @foo = 0
           @bar = 0
-          on_system :linux, macos: :monterey do
+          on_system :linux, macos: :tahoe do
             @foo = 1
           end
-          on_system :linux, macos: :big_sur_or_older do
+          on_system :linux, macos: :sonoma_or_older do
             @bar = 1
           end
         end
       end.new
     end
 
-    it "doesn't call code on Ventura", :needs_macos do
-      Homebrew::SimulateSystem.with os: :ventura do
+    it "doesn't call code on Sequoia", :needs_macos do
+      Homebrew::SimulateSystem.with os: :sequoia do
         f.brew { f.install }
         expect(f.foo).to eq(0)
         expect(f.bar).to eq(0)
@@ -1790,24 +1793,24 @@ def install
       end
     end
 
-    it "calls code within `on_system :linux, macos: :monterey` on Monterey", :needs_macos do
-      Homebrew::SimulateSystem.with os: :monterey do
+    it "calls code within `on_system :linux, macos: :tahoe` on Tahoe", :needs_macos do
+      Homebrew::SimulateSystem.with os: :tahoe do
         f.brew { f.install }
         expect(f.foo).to eq(1)
         expect(f.bar).to eq(0)
       end
     end
 
-    it "calls code within `on_system :linux, macos: :big_sur_or_older` on Big Sur", :needs_macos do
-      Homebrew::SimulateSystem.with os: :big_sur do
+    it "calls code within `on_system :linux, macos: :sonoma_or_older` on Sonoma", :needs_macos do
+      Homebrew::SimulateSystem.with os: :sonoma do
         f.brew { f.install }
         expect(f.foo).to eq(0)
         expect(f.bar).to eq(1)
       end
     end
 
-    it "calls code within `on_system :linux, macos: :big_sur_or_older` on Catalina", :needs_macos do
-      Homebrew::SimulateSystem.with os: :catalina do
+    it "calls code within `on_system :linux, macos: :sonoma_or_older` on Ventura", :needs_macos do
+      Homebrew::SimulateSystem.with os: :ventura do
         f.brew { f.install }
         expect(f.foo).to eq(0)
         expect(f.bar).to eq(1)
@@ -1822,49 +1825,49 @@ def install
 
         def install
           @test = 0
-          on_monterey :or_newer do
+          on_sequoia :or_newer do
             @test = 1
           end
-          on_big_sur do
+          on_sonoma do
             @test = 2
           end
-          on_catalina :or_older do
+          on_ventura :or_older do
             @test = 3
           end
         end
       end.new
     end
 
-    it "only calls code within `on_monterey`" do
-      Homebrew::SimulateSystem.with os: :monterey do
+    it "only calls code within `on_sequoia`" do
+      Homebrew::SimulateSystem.with os: :tahoe do
         f.brew { f.install }
         expect(f.test).to eq(1)
       end
     end
 
-    it "only calls code within `on_monterey :or_newer`" do
-      Homebrew::SimulateSystem.with os: :ventura do
+    it "only calls code within `on_sequoia :or_newer`" do
+      Homebrew::SimulateSystem.with os: :sequoia do
         f.brew { f.install }
         expect(f.test).to eq(1)
       end
     end
 
-    it "only calls code within `on_big_sur`" do
-      Homebrew::SimulateSystem.with os: :big_sur do
+    it "only calls code within `on_sonoma`" do
+      Homebrew::SimulateSystem.with os: :sonoma do
         f.brew { f.install }
         expect(f.test).to eq(2)
       end
     end
 
-    it "only calls code within `on_catalina`" do
-      Homebrew::SimulateSystem.with os: :catalina do
+    it "only calls code within `on_ventura`" do
+      Homebrew::SimulateSystem.with os: :ventura do
         f.brew { f.install }
         expect(f.test).to eq(3)
       end
     end
 
-    it "only calls code within `on_catalina :or_older`" do
-      Homebrew::SimulateSystem.with os: :mojave do
+    it "only calls code within `on_ventura :or_older`" do
+      Homebrew::SimulateSystem.with os: :monterey do
         f.brew { f.install }
         expect(f.test).to eq(3)
       end
diff --git a/Library/Homebrew/test/macos_version_spec.rb b/Library/Homebrew/test/macos_version_spec.rb
index 706bcfc9a87a5..2314ec3c79b84 100644
--- a/Library/Homebrew/test/macos_version_spec.rb
+++ b/Library/Homebrew/test/macos_version_spec.rb
@@ -3,15 +3,15 @@
 require "macos_version"
 
 RSpec.describe MacOSVersion do
-  let(:version) { described_class.new("10.14") }
+  let(:version) { described_class.new("10.15") }
   let(:tahoe_major) { described_class.new("26.0") }
   let(:big_sur_major) { described_class.new("11.0") }
   let(:big_sur_update) { described_class.new("11.1") }
-  let(:frozen_version) { described_class.new("10.14").freeze }
+  let(:frozen_version) { described_class.new("10.15").freeze }
 
   describe "::kernel_major_version" do
     it "returns the kernel major version" do
-      expect(described_class.kernel_major_version(version)).to eq "18"
+      expect(described_class.kernel_major_version(version)).to eq "19"
       expect(described_class.kernel_major_version(tahoe_major)).to eq "25"
       expect(described_class.kernel_major_version(big_sur_major)).to eq "20"
       expect(described_class.kernel_major_version(big_sur_update)).to eq "20"
@@ -30,7 +30,7 @@
     end
 
     it "creates a new version from a valid macOS version" do
-      symbol_version = described_class.from_symbol(:mojave)
+      symbol_version = described_class.from_symbol(:catalina)
       expect(symbol_version).to eq(version)
     end
   end
@@ -49,15 +49,15 @@
   end
 
   specify "comparison with Symbol" do
-    expect(version).to be > :high_sierra
-    expect(version).to eq :mojave
+    expect(version).to be >= :catalina
+    expect(version).to eq :catalina
     # We're explicitly testing the `===` operator results here.
-    expect(version).to be === :mojave # rubocop:disable Style/CaseEquality
-    expect(version).to be < :catalina
+    expect(version).to be === :catalina # rubocop:disable Style/CaseEquality
+    expect(version).to be < :tahoe
 
     # This should work like a normal comparison but the result won't be added
     # to the `@comparison_cache` hash because the object is frozen.
-    expect(frozen_version).to eq :mojave
+    expect(frozen_version).to eq :catalina
     expect(frozen_version.instance_variable_get(:@comparison_cache)).to eq({})
   end
 
@@ -68,18 +68,18 @@
 
   specify "comparison with String" do
     expect(version).to be > "10.3"
-    expect(version).to eq "10.14"
+    expect(version).to eq "10.15"
     # We're explicitly testing the `===` operator results here.
-    expect(version).to be === "10.14" # rubocop:disable Style/CaseEquality
-    expect(version).to be < "10.15"
+    expect(version).to be === "10.15" # rubocop:disable Style/CaseEquality
+    expect(version).to be < "11"
   end
 
   specify "comparison with Version" do
     expect(version).to be > Version.new("10.3")
-    expect(version).to eq Version.new("10.14")
+    expect(version).to eq Version.new("10.15")
     # We're explicitly testing the `===` operator results here.
-    expect(version).to be === Version.new("10.14") # rubocop:disable Style/CaseEquality
-    expect(version).to be < Version.new("10.15")
+    expect(version).to be === Version.new("10.15") # rubocop:disable Style/CaseEquality
+    expect(version).to be < Version.new("11")
   end
 
   describe "after Big Sur" do
@@ -112,7 +112,7 @@
   end
 
   specify "#to_sym" do
-    version_symbol = :mojave
+    version_symbol = :catalina
 
     # We call this more than once to exercise the caching logic
     expect(version.to_sym).to eq(version_symbol)
@@ -127,9 +127,9 @@
   end
 
   specify "#pretty_name" do
-    version_pretty_name = "Mojave"
+    version_pretty_name = "Catalina"
 
-    expect(described_class.new("10.11").pretty_name).to eq("El Capitan")
+    expect(described_class.new("11").pretty_name).to eq("Big Sur")
 
     # We call this more than once to exercise the caching logic
     expect(version.pretty_name).to eq(version_pretty_name)
@@ -163,19 +163,14 @@
     context "when CPU is Intel" do
       it "returns true if version requires a Nehalem CPU" do
         allow(Hardware::CPU).to receive(:type).and_return(:intel)
-        expect(described_class.new("10.14").requires_nehalem_cpu?).to be true
-      end
-
-      it "returns false if version does not require a Nehalem CPU" do
-        allow(Hardware::CPU).to receive(:type).and_return(:intel)
-        expect(described_class.new("10.12").requires_nehalem_cpu?).to be false
+        expect(described_class.new("10.15").requires_nehalem_cpu?).to be true
       end
     end
 
     context "when CPU is not Intel" do
       it "raises an error" do
         allow(Hardware::CPU).to receive(:type).and_return(:arm)
-        expect { described_class.new("10.14").requires_nehalem_cpu? }
+        expect { described_class.new("10.15").requires_nehalem_cpu? }
           .to raise_error(ArgumentError)
       end
     end
diff --git a/Library/Homebrew/test/os/linux/formula_spec.rb b/Library/Homebrew/test/os/linux/formula_spec.rb
index 0149343376bfa..c8116bf178218 100644
--- a/Library/Homebrew/test/os/linux/formula_spec.rb
+++ b/Library/Homebrew/test/os/linux/formula_spec.rb
@@ -24,7 +24,7 @@
       f = formula "foo" do
         url "foo-1.0"
 
-        uses_from_macos "foo", since: :mojave
+        uses_from_macos "foo", since: :sequoia
       end
 
       expect(f.class.stable.deps.first.name).to eq("foo")
diff --git a/Library/Homebrew/test/os/mac/diagnostic_spec.rb b/Library/Homebrew/test/os/mac/diagnostic_spec.rb
index fc74b2d4aa8b2..20d4504a33c41 100644
--- a/Library/Homebrew/test/os/mac/diagnostic_spec.rb
+++ b/Library/Homebrew/test/os/mac/diagnostic_spec.rb
@@ -8,7 +8,7 @@
   specify "#check_for_unsupported_macos" do
     ENV.delete("HOMEBREW_DEVELOPER")
 
-    macos_version = MacOSVersion.new("10.14")
+    macos_version = MacOSVersion.new("30")
     allow(OS::Mac).to receive_messages(version: macos_version, full_version: macos_version)
     allow(OS::Mac.version).to receive_messages(outdated_release?: false, prerelease?: true)
 
@@ -17,12 +17,12 @@
   end
 
   specify "#check_if_xcode_needs_clt_installed" do
-    macos_version = MacOSVersion.new("10.11")
+    macos_version = MacOSVersion.new("11")
     allow(OS::Mac).to receive_messages(version: macos_version, full_version: macos_version)
     allow(OS::Mac::Xcode).to receive_messages(installed?: true, version: "8.0", without_clt?: true)
 
     expect(checks.check_if_xcode_needs_clt_installed)
-      .to match("Xcode alone is not sufficient on El Capitan")
+      .to match("Xcode alone is not sufficient on Big Sur")
   end
 
   describe "#check_if_supported_sdk_available" do
diff --git a/Library/Homebrew/test/os/mac/formula_spec.rb b/Library/Homebrew/test/os/mac/formula_spec.rb
index 0a242912be347..a1ce7bad3f086 100644
--- a/Library/Homebrew/test/os/mac/formula_spec.rb
+++ b/Library/Homebrew/test/os/mac/formula_spec.rb
@@ -7,14 +7,14 @@
   describe "#uses_from_macos" do
     before do
       allow(OS).to receive(:mac?).and_return(true)
-      allow(OS::Mac).to receive(:version).and_return(MacOSVersion.from_symbol(:sierra))
+      allow(OS::Mac).to receive(:version).and_return(MacOSVersion.from_symbol(:sonoma))
     end
 
     it "adds a macOS dependency to all specs if the OS version meets requirements" do
       f = formula "foo" do
         url "foo-1.0"
 
-        uses_from_macos("foo", since: :el_capitan)
+        uses_from_macos("foo", since: :big_sur)
       end
 
       expect(f.class.stable.deps).to be_empty
@@ -29,7 +29,7 @@
       f = formula "foo" do
         url "foo-1.0"
 
-        uses_from_macos("foo", since: :high_sierra)
+        uses_from_macos("foo", since: :tahoe)
       end
 
       expect(f.class.stable.deps).not_to be_empty
diff --git a/Library/Homebrew/test/os/mac/pkgconfig_spec.rb b/Library/Homebrew/test/os/mac/pkgconfig_spec.rb
index 2c42559bd6c2c..70e45eb5c32d9 100644
--- a/Library/Homebrew/test/os/mac/pkgconfig_spec.rb
+++ b/Library/Homebrew/test/os/mac/pkgconfig_spec.rb
@@ -10,6 +10,7 @@
 # - uuid (not a standalone library)
 #
 # Additionally, libffi version detection cannot be performed on systems running Mojave or earlier.
+# TODO: we no longer support Mojave or earlier, so we can fix this now.
 #
 # For indeterminable cases, consult https://opensource.apple.com for the version used.
 RSpec.describe "pkg-config", :needs_ci, type: :system do
diff --git a/Library/Homebrew/test/os/mac/sdk_spec.rb b/Library/Homebrew/test/os/mac/sdk_spec.rb
index cc039aa729c9b..8ea6f8e12c05c 100644
--- a/Library/Homebrew/test/os/mac/sdk_spec.rb
+++ b/Library/Homebrew/test/os/mac/sdk_spec.rb
@@ -47,8 +47,6 @@
 
   describe "#all_sdks" do
     let(:big_sur_sdk_prefix) { TEST_FIXTURE_DIR/"sdks/big_sur" }
-    let(:mojave_broken_sdk_prefix) { TEST_FIXTURE_DIR/"sdks/mojave_broken" }
-    let(:high_sierra_sdk_prefix) { TEST_FIXTURE_DIR/"sdks/high_sierra" }
     let(:malformed_sdk_prefix) { TEST_FIXTURE_DIR/"sdks/malformed" }
 
     it "reads the SDKSettings.json version of unversioned SDKs folders" do
@@ -63,30 +61,6 @@
       expect(sdk.source).to eq(:clt)
     end
 
-    it "reads the SDKSettings.json version of versioned SDKs folders" do
-      allow(locator).to receive(:sdk_prefix).and_return(mojave_broken_sdk_prefix.to_s)
-
-      sdks = locator.all_sdks
-      expect(sdks.count).to eq(1)
-
-      sdk = sdks.first
-      expect(sdk.path).to eq(mojave_broken_sdk_prefix/"MacOSX10.14.sdk")
-      expect(sdk.version).to eq(MacOSVersion.new("10.15"))
-      expect(sdk.source).to eq(:clt)
-    end
-
-    it "reads the SDKSettings.plist version" do
-      allow(locator).to receive(:sdk_prefix).and_return(high_sierra_sdk_prefix.to_s)
-
-      sdks = locator.all_sdks
-      expect(sdks.count).to eq(1)
-
-      sdk = sdks.first
-      expect(sdk.path).to eq(high_sierra_sdk_prefix/"MacOSX10.13.sdk")
-      expect(sdk.version).to eq(MacOSVersion.new("10.13"))
-      expect(sdk.source).to eq(:clt)
-    end
-
     it "rejects malformed sdks" do
       allow(locator).to receive(:sdk_prefix).and_return(malformed_sdk_prefix.to_s)
 
diff --git a/Library/Homebrew/test/requirements/macos_requirement_spec.rb b/Library/Homebrew/test/requirements/macos_requirement_spec.rb
index f983abd2790fe..963b2fce594c0 100644
--- a/Library/Homebrew/test/requirements/macos_requirement_spec.rb
+++ b/Library/Homebrew/test/requirements/macos_requirement_spec.rb
@@ -7,7 +7,7 @@
 
   let(:macos_oldest_allowed) { MacOSVersion.new(HOMEBREW_MACOS_OLDEST_ALLOWED) }
   let(:macos_newest_allowed) { MacOSVersion.new(HOMEBREW_MACOS_NEWEST_UNSUPPORTED) }
-  let(:big_sur_major) { MacOSVersion.new("11.0") }
+  let(:tahoe_major) { MacOSVersion.new("26.0") }
 
   describe "#satisfied?" do
     it "returns true on macOS" do
@@ -27,40 +27,40 @@
 
   specify "#minimum_version" do
     no_requirement = described_class.new
-    max_requirement = described_class.new([:big_sur], comparator: "<=")
-    min_requirement = described_class.new([:big_sur], comparator: ">=")
-    exact_requirement = described_class.new([:big_sur], comparator: "==")
-    range_requirement = described_class.new([[:monterey, :big_sur]], comparator: "==")
+    max_requirement = described_class.new([:tahoe], comparator: "<=")
+    min_requirement = described_class.new([:tahoe], comparator: ">=")
+    exact_requirement = described_class.new([:tahoe], comparator: "==")
+    range_requirement = described_class.new([[:sonoma, :tahoe]], comparator: "==")
     expect(no_requirement.minimum_version).to eq macos_oldest_allowed
     expect(max_requirement.minimum_version).to eq macos_oldest_allowed
-    expect(min_requirement.minimum_version).to eq big_sur_major
-    expect(exact_requirement.minimum_version).to eq big_sur_major
-    expect(range_requirement.minimum_version).to eq big_sur_major
+    expect(min_requirement.minimum_version).to eq tahoe_major
+    expect(exact_requirement.minimum_version).to eq tahoe_major
+    expect(range_requirement.minimum_version).to eq "14"
   end
 
   specify "#maximum_version" do
     no_requirement = described_class.new
-    max_requirement = described_class.new([:big_sur], comparator: "<=")
-    min_requirement = described_class.new([:big_sur], comparator: ">=")
-    exact_requirement = described_class.new([:big_sur], comparator: "==")
-    range_requirement = described_class.new([[:catalina, :big_sur]], comparator: "==")
+    max_requirement = described_class.new([:tahoe], comparator: "<=")
+    min_requirement = described_class.new([:tahoe], comparator: ">=")
+    exact_requirement = described_class.new([:tahoe], comparator: "==")
+    range_requirement = described_class.new([[:sonoma, :tahoe]], comparator: "==")
     expect(no_requirement.maximum_version).to eq macos_newest_allowed
-    expect(max_requirement.maximum_version).to eq big_sur_major
+    expect(max_requirement.maximum_version).to eq tahoe_major
     expect(min_requirement.maximum_version).to eq macos_newest_allowed
-    expect(exact_requirement.maximum_version).to eq big_sur_major
-    expect(range_requirement.maximum_version).to eq big_sur_major
+    expect(exact_requirement.maximum_version).to eq tahoe_major
+    expect(range_requirement.maximum_version).to eq tahoe_major
   end
 
   specify "#allows?" do
     no_requirement = described_class.new
-    max_requirement = described_class.new([:mojave], comparator: "<=")
-    min_requirement = described_class.new([:catalina], comparator: ">=")
-    exact_requirement = described_class.new([:big_sur], comparator: "==")
-    range_requirement = described_class.new([[:monterey, :big_sur]], comparator: "==")
-    expect(no_requirement.allows?(big_sur_major)).to be true
-    expect(max_requirement.allows?(big_sur_major)).to be false
-    expect(min_requirement.allows?(big_sur_major)).to be true
-    expect(exact_requirement.allows?(big_sur_major)).to be true
-    expect(range_requirement.allows?(big_sur_major)).to be true
+    max_requirement = described_class.new([:sequoia], comparator: "<=")
+    min_requirement = described_class.new([:ventura], comparator: ">=")
+    exact_requirement = described_class.new([:tahoe], comparator: "==")
+    range_requirement = described_class.new([[:sonoma, :tahoe]], comparator: "==")
+    expect(no_requirement.allows?(tahoe_major)).to be true
+    expect(max_requirement.allows?(tahoe_major)).to be false
+    expect(min_requirement.allows?(tahoe_major)).to be true
+    expect(exact_requirement.allows?(tahoe_major)).to be true
+    expect(range_requirement.allows?(tahoe_major)).to be true
   end
 end
diff --git a/Library/Homebrew/test/rubocops/cask/desc_spec.rb b/Library/Homebrew/test/rubocops/cask/desc_spec.rb
index dc3fe2629afee..3867c6514f2e9 100644
--- a/Library/Homebrew/test/rubocops/cask/desc_spec.rb
+++ b/Library/Homebrew/test/rubocops/cask/desc_spec.rb
@@ -78,8 +78,8 @@
 
     expect_offense <<~RUBY, "/homebrew-cask/Casks/foo.rb"
       cask 'foo-bar' do
-        desc 'Toggles dark mode on Mac OS Mojave'
-                                   ^^^^^^ Description shouldn't contain the platform.
+        desc 'Toggles dark mode on macOS Catalina'
+                                   ^^^^^ Description shouldn't contain the platform.
       end
     RUBY
 
diff --git a/Library/Homebrew/test/rubocops/cask/no_overrides_spec.rb b/Library/Homebrew/test/rubocops/cask/no_overrides_spec.rb
index b6c4099c63a03..0da76c44e7ded 100644
--- a/Library/Homebrew/test/rubocops/cask/no_overrides_spec.rb
+++ b/Library/Homebrew/test/rubocops/cask/no_overrides_spec.rb
@@ -17,7 +17,7 @@
   it "accepts when there are no top-level standalone stanzas" do
     expect_no_offenses <<~CASK
       cask 'foo' do
-        on_mojave :or_later do
+        on_sequoia :or_later do
           version :latest
         end
       end
@@ -46,7 +46,7 @@
         arch arm: "arm64", intel: "x86"
         version '1.2.3'
 
-        on_mojave :or_later do
+        on_sequoia :or_later do
           sha256 "aaa"
 
           url "https://brew.sh/foo-\#{version}-\#{arch}.pkg"
@@ -60,7 +60,7 @@
       cask 'foo' do
         version '0.99,123.3'
 
-        on_mojave :or_later do
+        on_sequoia :or_later do
           url "https://brew.sh/foo-\#{version.csv.first}-\#{version.csv.second}.pkg"
         end
       end
@@ -74,7 +74,7 @@
 
         version '0.99,123.3'
 
-        on_mojave :or_later do
+        on_sequoia :or_later do
           url "https://brew.sh/foo-\#{arch}-\#{version.csv.first}-\#{version.csv.last}.pkg"
 
           livecheck do
@@ -148,7 +148,7 @@
         version '2.3.4'
         ^^^^^^^^^^^^^^^ Do not use a top-level `version` stanza as the default. Add it to an `on_{system}` block instead. Use `:or_older` or `:or_newer` to specify a range of macOS versions.
 
-        on_mojave :or_older do
+        on_sequoia :or_older do
           version '1.2.3'
         end
 
diff --git a/Library/Homebrew/test/rubocops/cask/stanza_order_spec.rb b/Library/Homebrew/test/rubocops/cask/stanza_order_spec.rb
index c1a84a458b977..4fd41e18dab68 100644
--- a/Library/Homebrew/test/rubocops/cask/stanza_order_spec.rb
+++ b/Library/Homebrew/test/rubocops/cask/stanza_order_spec.rb
@@ -397,17 +397,18 @@
           url "https://foo.brew.sh/foo-ventura.zip"
         end
         on_catalina do
+        ^^^^^^^^^^^^^^ `on_catalina` stanza out of order
           sha256 "def456"
           ^^^^^^^^^^^^^^^ `sha256` stanza out of order
           version "0.7"
           ^^^^^^^^^^^^^ `version` stanza out of order
           url "https://foo.brew.sh/foo-catalina.zip"
         end
-        on_mojave do
-        ^^^^^^^^^^^^ `on_mojave` stanza out of order
+        on_sequoia do
+        ^^^^^^^^^^^^^ `on_sequoia` stanza out of order
           version :latest
           sha256 "ghi789"
-          url "https://foo.brew.sh/foo-mojave.zip"
+          url "https://foo.brew.sh/foo-sequoia.zip"
         end
         on_big_sur do
         ^^^^^^^^^^^^^ `on_big_sur` stanza out of order
@@ -423,11 +424,6 @@
 
     expect_correction <<~CASK
       cask "foo" do
-        on_mojave do
-          version :latest
-          sha256 "ghi789"
-          url "https://foo.brew.sh/foo-mojave.zip"
-        end
         on_catalina do
           version "0.7"
           sha256 "def456"
@@ -444,6 +440,11 @@
           sha256 "abc123"
           url "https://foo.brew.sh/foo-ventura.zip"
         end
+        on_sequoia do
+          version :latest
+          sha256 "ghi789"
+          url "https://foo.brew.sh/foo-sequoia.zip"
+        end
       end
     CASK
   end
diff --git a/Library/Homebrew/test/rubocops/text/miscellaneous_spec.rb b/Library/Homebrew/test/rubocops/text/miscellaneous_spec.rb
index f3f15fecd35a7..8847fd2521a04 100644
--- a/Library/Homebrew/test/rubocops/text/miscellaneous_spec.rb
+++ b/Library/Homebrew/test/rubocops/text/miscellaneous_spec.rb
@@ -38,7 +38,7 @@ class Foo < Formula
           bottle do
             rebuild 0
             ^^^^^^^^^ FormulaAudit/Miscellaneous: `rebuild 0` should be removed
-            sha256 "fe0679b932dd43a87fd415b609a7fbac7a069d117642ae8ebaac46ae1fb9f0b3" => :sierra
+            sha256 "fe0679b932dd43a87fd415b609a7fbac7a069d117642ae8ebaac46ae1fb9f0b3" => :sonoma
           end
         end
       RUBY
@@ -50,7 +50,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           bottle do
-            sha256 "fe0679b932dd43a87fd415b609a7fbac7a069d117642ae8ebaac46ae1fb9f0b3" => :sierra
+            sha256 "fe0679b932dd43a87fd415b609a7fbac7a069d117642ae8ebaac46ae1fb9f0b3" => :sonoma
           end
           fails_with :llvm do
           ^^^^^^^^^^^^^^^^ FormulaAudit/Miscellaneous: `fails_with :llvm` is now a no-op and should be removed
diff --git a/Library/Homebrew/test/software_spec_spec.rb b/Library/Homebrew/test/software_spec_spec.rb
index 37770dac9eea7..e964df1a8bb48 100644
--- a/Library/Homebrew/test/software_spec_spec.rb
+++ b/Library/Homebrew/test/software_spec_spec.rb
@@ -180,8 +180,8 @@
       end
 
       it "ignores OS version specifications" do
-        spec.uses_from_macos("foo", since: :mojave)
-        spec.uses_from_macos("bar" => :build, :since => :mojave)
+        spec.uses_from_macos("foo", since: :sequoia)
+        spec.uses_from_macos("bar" => :build, :since => :sequoia)
 
         expect(spec.deps.count).to eq 2
         expect(spec.deps.first.name).to eq("foo")
@@ -198,11 +198,11 @@
     context "when running on macOS", :needs_macos do
       before do
         allow(OS).to receive(:mac?).and_return(true)
-        allow(OS::Mac).to receive(:version).and_return(MacOSVersion.from_symbol(:sierra))
+        allow(OS::Mac).to receive(:version).and_return(MacOSVersion.from_symbol(:sonoma))
       end
 
       it "adds a macOS dependency if the OS version meets requirements" do
-        spec.uses_from_macos("foo", since: :el_capitan)
+        spec.uses_from_macos("foo", since: :sonoma)
 
         expect(spec.deps).to be_empty
         expect(spec.declared_deps).not_to be_empty
@@ -211,7 +211,7 @@
       end
 
       it "adds a macOS dependency if the OS version doesn't meet requirements" do
-        spec.uses_from_macos("foo", since: :high_sierra)
+        spec.uses_from_macos("foo", since: :big_sur)
 
         expect(spec.declared_deps).not_to be_empty
         expect(spec.deps).not_to be_empty
@@ -221,7 +221,7 @@
       end
 
       it "works with tags" do
-        spec.uses_from_macos("foo" => :build, :since => :high_sierra)
+        spec.uses_from_macos("foo" => :build, :since => :big_sur)
 
         expect(spec.declared_deps).not_to be_empty
         expect(spec.deps).not_to be_empty
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/invalid/conflicts-with-deprecated-key.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/invalid/conflicts-with-disabled-key.rb
similarity index 68%
rename from Library/Homebrew/test/support/fixtures/cask/Casks/invalid/conflicts-with-deprecated-key.rb
rename to Library/Homebrew/test/support/fixtures/cask/Casks/invalid/conflicts-with-disabled-key.rb
index a8c1474787073..e49a76710f9a4 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/invalid/conflicts-with-deprecated-key.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/invalid/conflicts-with-disabled-key.rb
@@ -1,9 +1,9 @@
-cask "conflicts-with-deprecated-key" do
+cask "conflicts-with-disabled-key" do
   version "1.2.3"
   sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
 
   url "file://#{TEST_FIXTURE_DIR}/cask/caffeine.zip"
-  homepage "https://brew.sh/conflicts-with-deprecated-key"
+  homepage "https://brew.sh/conflicts-with-disabled-key"
 
   conflicts_with formula: "some-formula"
 
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/invalid/invalid-depends-on-macos-conflicting-forms.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/invalid/invalid-depends-on-macos-conflicting-forms.rb
index 487d1311c63dc..0127575266c81 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/invalid/invalid-depends-on-macos-conflicting-forms.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/invalid/invalid-depends-on-macos-conflicting-forms.rb
@@ -7,8 +7,8 @@
   url "file://#{TEST_FIXTURE_DIR}/cask/caffeine.zip"
   homepage "https://brew.sh/invalid-depends-on-macos-conflicting-forms"
 
-  depends_on macos: :catalina
-  depends_on macos: ">= :mojave"
+  depends_on macos: :sequoia
+  depends_on macos: ">= :sonoma"
 
   app "Caffeine.app"
 end
diff --git a/Library/Homebrew/test/support/fixtures/sdks/high_sierra/MacOSX10.13.sdk/SDKSettings.plist b/Library/Homebrew/test/support/fixtures/sdks/high_sierra/MacOSX10.13.sdk/SDKSettings.plist
deleted file mode 100644
index 7e57e7b0813ab..0000000000000
--- a/Library/Homebrew/test/support/fixtures/sdks/high_sierra/MacOSX10.13.sdk/SDKSettings.plist
+++ /dev/null
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>Version</key>
-	<string>10.13</string>
-</dict>
-</plist>
diff --git a/Library/Homebrew/test/support/fixtures/sdks/mojave_broken/MacOSX10.14.sdk/SDKSettings.json b/Library/Homebrew/test/support/fixtures/sdks/mojave_broken/MacOSX10.14.sdk/SDKSettings.json
deleted file mode 100644
index 62938d457a0f3..0000000000000
--- a/Library/Homebrew/test/support/fixtures/sdks/mojave_broken/MacOSX10.14.sdk/SDKSettings.json
+++ /dev/null
@@ -1 +0,0 @@
-{"Version":"10.15.6"}
diff --git a/Library/Homebrew/test/test_runner_formula_spec.rb b/Library/Homebrew/test/test_runner_formula_spec.rb
index 3f0064a3bf0d7..afdb3b5c55f60 100644
--- a/Library/Homebrew/test/test_runner_formula_spec.rb
+++ b/Library/Homebrew/test/test_runner_formula_spec.rb
@@ -376,13 +376,13 @@
           end
         end
 
-        context "when given `{ platform: :macos, arch: :x86_64, macos_version: :mojave }`" do
+        context "when given `{ platform: :macos, arch: :x86_64, macos_version: :sonoma }`" do
           it "returns only the dependents for the requested platform and architecture" do
             allow(Formula).to receive(:all).and_wrap_original { testball_and_dependents }
 
             expect(
               described_class.new(testball, eval_all: true).dependents(
-                platform: :macos, arch: :x86_64, macos_version: :mojave,
+                platform: :macos, arch: :x86_64, macos_version: :sonoma,
               ).map(&:name).sort,
             ).to eq(["testball_user", "testball_user-intel", "testball_user-macos"].sort)
           end
diff --git a/Library/Homebrew/test/utils/ast/formula_ast_spec.rb b/Library/Homebrew/test/utils/ast/formula_ast_spec.rb
index 09492ac1a2dac..7efb1212a71ef 100644
--- a/Library/Homebrew/test/utils/ast/formula_ast_spec.rb
+++ b/Library/Homebrew/test/utils/ast/formula_ast_spec.rb
@@ -54,7 +54,7 @@ class Foo < Formula
             license :cannot_represent
 
             bottle do
-              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sierra
+              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sonoma
             end
           end
         RUBY
@@ -66,7 +66,7 @@ class Foo < Formula
             url "https://brew.sh/foo-1.0.tar.gz"
 
             bottle do
-              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sierra
+              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sonoma
             end
           end
         RUBY
@@ -90,7 +90,7 @@ class Foo < Formula
             ]
 
             bottle do
-              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sierra
+              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sonoma
             end
           end
         RUBY
@@ -102,7 +102,7 @@ class Foo < Formula
             url "https://brew.sh/foo-1.0.tar.gz"
 
             bottle do
-              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sierra
+              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sonoma
             end
           end
         RUBY
@@ -122,7 +122,7 @@ class Foo < Formula
             license :cannot_represent # comment
 
             bottle do
-              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sierra
+              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sonoma
             end
           end
         RUBY
@@ -135,7 +135,7 @@ class Foo < Formula
              # comment
 
             bottle do
-              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sierra
+              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sonoma
             end
           end
         RUBY
@@ -156,7 +156,7 @@ class Foo < Formula
             # comment
 
             bottle do
-              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sierra
+              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sonoma
             end
           end
         RUBY
@@ -169,7 +169,7 @@ class Foo < Formula
             # comment
 
             bottle do
-              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sierra
+              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sonoma
             end
           end
         RUBY
@@ -188,7 +188,7 @@ class Foo < Formula
             url "https://brew.sh/foo-1.0.tar.gz"
 
             bottle do
-              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sierra
+              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sonoma
             end
 
             head do
@@ -226,7 +226,7 @@ class Foo < Formula
             license :cannot_represent
 
             bottle do
-              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sierra
+              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sonoma
             end
           end
         RUBY
@@ -252,7 +252,7 @@ class Foo < Formula
     let(:bottle_output) do
       <<-RUBY
   bottle do
-    sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sierra
+    sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sonoma
   end
       RUBY
     end
@@ -274,7 +274,7 @@ class Foo < Formula
             license "MIT"
 
             bottle do
-              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sierra
+              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sonoma
             end
           end
         RUBY
@@ -303,7 +303,7 @@ class Foo < Formula
             license :cannot_represent
 
             bottle do
-              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sierra
+              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sonoma
             end
           end
         RUBY
@@ -340,7 +340,7 @@ class Foo < Formula
             ]
 
             bottle do
-              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sierra
+              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sonoma
             end
           end
         RUBY
@@ -369,7 +369,7 @@ class Foo < Formula
             head "https://brew.sh/foo.git", branch: "develop"
 
             bottle do
-              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sierra
+              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sonoma
             end
           end
         RUBY
@@ -401,7 +401,7 @@ class Foo < Formula
             url "https://brew.sh/foo-1.0.tar.gz"
 
             bottle do
-              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sierra
+              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sonoma
             end
 
             head do
@@ -433,7 +433,7 @@ class Foo < Formula
             url "https://brew.sh/foo-1.0.tar.gz" # comment
 
             bottle do
-              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sierra
+              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sonoma
             end
           end
         RUBY
@@ -462,7 +462,7 @@ class Foo < Formula
             # comment
 
             bottle do
-              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sierra
+              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sonoma
             end
           end
         RUBY
@@ -491,7 +491,7 @@ class Foo < Formula
             url "https://brew.sh/foo-1.0.tar.gz"
 
             bottle do
-              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sierra
+              sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sonoma
             end
 
             # comment
diff --git a/Library/Homebrew/test/utils/bottles/collector_spec.rb b/Library/Homebrew/test/utils/bottles/collector_spec.rb
index de10dbb541b65..6525bba97e4c9 100644
--- a/Library/Homebrew/test/utils/bottles/collector_spec.rb
+++ b/Library/Homebrew/test/utils/bottles/collector_spec.rb
@@ -5,16 +5,17 @@
 RSpec.describe Utils::Bottles::Collector do
   subject(:collector) { described_class.new }
 
-  let(:catalina) { Utils::Bottles::Tag.from_symbol(:catalina) }
-  let(:mojave) { Utils::Bottles::Tag.from_symbol(:mojave) }
+  let(:tahoe) { Utils::Bottles::Tag.from_symbol(:tahoe) }
+  let(:sequoia) { Utils::Bottles::Tag.from_symbol(:sequoia) }
+  let(:sonoma) { Utils::Bottles::Tag.from_symbol(:sonoma) }
 
   describe "#specification_for" do
     it "returns passed tags" do
-      collector.add(mojave, checksum: Checksum.new("foo_checksum"), cellar: "foo_cellar")
-      collector.add(catalina, checksum: Checksum.new("bar_checksum"), cellar: "bar_cellar")
-      spec = collector.specification_for(catalina)
+      collector.add(sonoma, checksum: Checksum.new("foo_checksum"), cellar: "foo_cellar")
+      collector.add(sequoia, checksum: Checksum.new("bar_checksum"), cellar: "bar_cellar")
+      spec = collector.specification_for(sequoia)
       expect(spec).not_to be_nil
-      expect(spec.tag).to eq(catalina)
+      expect(spec.tag).to eq(sequoia)
       expect(spec.checksum).to eq("bar_checksum")
       expect(spec.cellar).to eq("bar_cellar")
     end
@@ -24,30 +25,30 @@
     end
 
     it "returns nil when there is no match" do
-      collector.add(catalina, checksum: Checksum.new("bar_checksum"), cellar: "bar_cellar")
+      collector.add(sequoia, checksum: Checksum.new("bar_checksum"), cellar: "bar_cellar")
       expect(collector.specification_for(Utils::Bottles::Tag.from_symbol(:foo))).to be_nil
     end
 
     it "uses older tags when needed", :needs_macos do
-      collector.add(mojave, checksum: Checksum.new("foo_checksum"), cellar: "foo_cellar")
-      expect(collector.send(:find_matching_tag, mojave)).to eq(mojave)
-      expect(collector.send(:find_matching_tag, catalina)).to eq(mojave)
+      collector.add(sonoma, checksum: Checksum.new("foo_checksum"), cellar: "foo_cellar")
+      expect(collector.send(:find_matching_tag, sonoma)).to eq(sonoma)
+      expect(collector.send(:find_matching_tag, sequoia)).to eq(sonoma)
     end
 
     it "does not use older tags when requested not to", :needs_macos do
       allow(Homebrew::EnvConfig).to receive_messages(developer?: true, skip_or_later_bottles?: true)
       allow(OS::Mac.version).to receive(:prerelease?).and_return(true)
-      collector.add(mojave, checksum: Checksum.new("foo_checksum"), cellar: "foo_cellar")
-      expect(collector.send(:find_matching_tag, mojave)).to eq(mojave)
-      expect(collector.send(:find_matching_tag, catalina)).to be_nil
+      collector.add(sonoma, checksum: Checksum.new("foo_checksum"), cellar: "foo_cellar")
+      expect(collector.send(:find_matching_tag, sonoma)).to eq(sonoma)
+      expect(collector.send(:find_matching_tag, sequoia)).to be_nil
     end
 
     it "ignores HOMEBREW_SKIP_OR_LATER_BOTTLES on release versions", :needs_macos do
       allow(Homebrew::EnvConfig).to receive(:skip_or_later_bottles?).and_return(true)
       allow(OS::Mac.version).to receive(:prerelease?).and_return(false)
-      collector.add(mojave, checksum: Checksum.new("foo_checksum"), cellar: "foo_cellar")
-      expect(collector.send(:find_matching_tag, mojave)).to eq(mojave)
-      expect(collector.send(:find_matching_tag, catalina)).to eq(mojave)
+      collector.add(sonoma, checksum: Checksum.new("foo_checksum"), cellar: "foo_cellar")
+      expect(collector.send(:find_matching_tag, sonoma)).to eq(sonoma)
+      expect(collector.send(:find_matching_tag, sequoia)).to eq(sonoma)
     end
   end
 end
diff --git a/Library/Homebrew/test/utils/bottles/tag_spec.rb b/Library/Homebrew/test/utils/bottles/tag_spec.rb
index 919e15deafbda..b6170a72bc600 100644
--- a/Library/Homebrew/test/utils/bottles/tag_spec.rb
+++ b/Library/Homebrew/test/utils/bottles/tag_spec.rb
@@ -63,11 +63,9 @@
       expect(tag.valid_combination?).to be true
     end
 
-    it "returns false for ARM on macOS Catalina or older" do
+    it "returns false for ARM on macOS Catalina" do
       tag = described_class.new(system: :catalina, arch: :arm64)
       expect(tag.valid_combination?).to be false
-      tag = described_class.new(system: :mojave, arch: :arm)
-      expect(tag.valid_combination?).to be false
     end
 
     it "returns true for ARM on macOS Big Sur or newer" do
diff --git a/Library/Homebrew/utils/string_inreplace_extension.rb b/Library/Homebrew/utils/string_inreplace_extension.rb
index 520d0c4ddec50..bd7d285181347 100644
--- a/Library/Homebrew/utils/string_inreplace_extension.rb
+++ b/Library/Homebrew/utils/string_inreplace_extension.rb
@@ -34,19 +34,12 @@ def sub!(before, after, audit_result: true)
   # @api public
   sig {
     params(
-      before:           T.any(Pathname, Regexp, String),
-      after:            T.any(Pathname, String),
-      old_audit_result: T.nilable(T::Boolean),
-      audit_result:     T::Boolean,
+      before:       T.any(Pathname, Regexp, String),
+      after:        T.any(Pathname, String),
+      audit_result: T::Boolean,
     ).returns(T.nilable(String))
   }
-  def gsub!(before, after, old_audit_result = nil, audit_result: true)
-    # NOTE: must check for `#nil?` and not `#blank?`, or else `old_audit_result = false` will not call `odisabled`.
-    unless old_audit_result.nil?
-      odisabled "gsub!(before, after, #{old_audit_result})",
-                "gsub!(before, after, audit_result: #{old_audit_result})"
-      audit_result = old_audit_result
-    end
+  def gsub!(before, after, audit_result: true)
     before = before.to_s if before.is_a?(Pathname)
     result = inreplace_string.gsub!(before, after.to_s)
     errors << "expected replacement of #{before.inspect} with #{after.inspect}" if audit_result && result.nil?
diff --git a/completions/bash/brew b/completions/bash/brew
index 9d42ecb533aab..624899c845ed8 100644
--- a/completions/bash/brew
+++ b/completions/bash/brew
@@ -676,7 +676,6 @@ _brew_bundle() {
       --upgrade-formulae
       --verbose
       --vscode
-      --whalebrew
       --zap
       "
       return
diff --git a/completions/fish/brew.fish b/completions/fish/brew.fish
index cdc37938e6087..f7f74b71e87f6 100644
--- a/completions/fish/brew.fish
+++ b/completions/fish/brew.fish
@@ -497,7 +497,7 @@ __fish_brew_complete_arg 'bump-unversioned-casks' -a '(__fish_brew_suggest_casks
 __fish_brew_complete_arg 'bump-unversioned-casks' -a '(__fish_brew_suggest_taps_installed)'
 
 
-__fish_brew_complete_cmd 'bundle' 'Bundler for non-Ruby dependencies from Homebrew, Homebrew Cask, Mac App Store, Whalebrew, Visual Studio Code (and forks/variants) and Go packages'
+__fish_brew_complete_cmd 'bundle' 'Bundler for non-Ruby dependencies from Homebrew, Homebrew Cask, Mac App Store, Visual Studio Code (and forks/variants) and Go packages'
 __fish_brew_complete_sub_cmd 'bundle' 'install'
 __fish_brew_complete_sub_cmd 'bundle' 'dump'
 __fish_brew_complete_sub_cmd 'bundle' 'cleanup'
@@ -531,7 +531,6 @@ __fish_brew_complete_arg 'bundle' -l upgrade -d '`install` runs `brew upgrade` o
 __fish_brew_complete_arg 'bundle' -l upgrade-formulae -d '`install` runs `brew upgrade` on any of these comma-separated formulae, even if `$HOMEBREW_BUNDLE_NO_UPGRADE` is set'
 __fish_brew_complete_arg 'bundle' -l verbose -d '`install` prints output from commands as they are run. `check` lists all missing dependencies'
 __fish_brew_complete_arg 'bundle' -l vscode -d '`list`, `dump` or `cleanup` VSCode (and forks/variants) extensions'
-__fish_brew_complete_arg 'bundle' -l whalebrew -d '`list` or `dump` Whalebrew dependencies'
 __fish_brew_complete_arg 'bundle' -l zap -d '`cleanup` casks using the `zap` command instead of `uninstall`'
 
 
diff --git a/completions/zsh/_brew b/completions/zsh/_brew
index 3e2b8840580fb..53d906ee10799 100644
--- a/completions/zsh/_brew
+++ b/completions/zsh/_brew
@@ -149,7 +149,7 @@ __brew_internal_commands() {
     'bump-formula-pr:Create a pull request to update formula with a new URL or a new tag'
     'bump-revision:Create a commit to increment the revision of formula'
     'bump-unversioned-casks:Check all casks with unversioned URLs in a given tap for updates'
-    'bundle:Bundler for non-Ruby dependencies from Homebrew, Homebrew Cask, Mac App Store, Whalebrew, Visual Studio Code (and forks/variants) and Go packages'
+    'bundle:Bundler for non-Ruby dependencies from Homebrew, Homebrew Cask, Mac App Store, Visual Studio Code (and forks/variants) and Go packages'
     'casks:List all locally installable casks including short names'
     'cat:Display the source of a formula or cask'
     'cleanup:Remove stale lock files and outdated downloads for all formulae and casks, and remove old versions of installed formulae'
@@ -681,7 +681,6 @@ _brew_bundle() {
     '--upgrade-formulae[`install` runs `brew upgrade` on any of these comma-separated formulae, even if `$HOMEBREW_BUNDLE_NO_UPGRADE` is set]' \
     '--verbose[`install` prints output from commands as they are run. `check` lists all missing dependencies]' \
     '(--no-vscode)--vscode[`list`, `dump` or `cleanup` VSCode (and forks/variants) extensions]' \
-    '--whalebrew[`list` or `dump` Whalebrew dependencies]' \
     '--zap[`cleanup` casks using the `zap` command instead of `uninstall`]' \
     - subcommand \
     '*:subcommand:(install dump cleanup check exec list sh env edit)'
diff --git a/docs/Adding-Software-to-Homebrew.md b/docs/Adding-Software-to-Homebrew.md
index 2c028e2ae68f7..ac34b9ff1064b 100644
--- a/docs/Adding-Software-to-Homebrew.md
+++ b/docs/Adding-Software-to-Homebrew.md
@@ -139,7 +139,7 @@ cask "fabfilter-one" do
     end
   end
 
-  depends_on macos: ">= :sierra"
+  depends_on macos: ">= :sonoma"
 
   pkg "FabFilter One #{version} Installer.pkg"
 
diff --git a/docs/Bottles.md b/docs/Bottles.md
index 855525a398cb1..b47d4db3dbf39 100644
--- a/docs/Bottles.md
+++ b/docs/Bottles.md
@@ -36,10 +36,9 @@ A simple (and typical) example:
 
 ```ruby
 bottle do
-  sha256 arm64_big_sur: "a9ae578b05c3da46cedc07dd428d94a856aeae7f3ef80a0f405bf89b8cde893a"
-  sha256 big_sur:       "5dc376aa20241233b76e2ec2c1d4e862443a0250916b2838a1ff871e8a6dc2c5"
-  sha256 catalina:      "924afbbc16549d8c2b80544fd03104ff8c17a4b1460238e3ed17a1313391a2af"
-  sha256 mojave:        "678d338adc7d6e8c352800fe03fc56660c796bd6da23eda2b1411fed18bd0d8d"
+  sha256 arm64_tahoe: "a9ae578b05c3da46cedc07dd428d94a856aeae7f3ef80a0f405bf89b8cde893a"
+  sha256 tahoe:       "5dc376aa20241233b76e2ec2c1d4e862443a0250916b2838a1ff871e8a6dc2c5"
+  sha256 sequoia:     "924afbbc16549d8c2b80544fd03104ff8c17a4b1460238e3ed17a1313391a2af"
 end
 ```
 
@@ -49,10 +48,9 @@ A full example:
 bottle do
   root_url "https://example.com"
   rebuild 4
-  sha256 cellar: "/opt/homebrew/Cellar", arm64_big_sur: "a9ae578b05c3da46cedc07dd428d94a856aeae7f3ef80a0f405bf89b8cde893a"
-  sha256 cellar: :any,                   big_sur:       "5dc376aa20241233b76e2ec2c1d4e862443a0250916b2838a1ff871e8a6dc2c5"
-  sha256                                 catalina:      "924afbbc16549d8c2b80544fd03104ff8c17a4b1460238e3ed17a1313391a2af"
-  sha256                                 mojave:        "678d338adc7d6e8c352800fe03fc56660c796bd6da23eda2b1411fed18bd0d8d"
+  sha256 cellar: "/opt/homebrew/Cellar", arm64_tahoe: "a9ae578b05c3da46cedc07dd428d94a856aeae7f3ef80a0f405bf89b8cde893a"
+  sha256 cellar: :any,                   tahoe:       "5dc376aa20241233b76e2ec2c1d4e862443a0250916b2838a1ff871e8a6dc2c5"
+  sha256                                 sequoia:     "924afbbc16549d8c2b80544fd03104ff8c17a4b1460238e3ed17a1313391a2af"
 end
 ```
 
diff --git a/docs/Brew-Bundle-and-Brewfile.md b/docs/Brew-Bundle-and-Brewfile.md
index 8e0f07ff3b388..7a11240a9a468 100644
--- a/docs/Brew-Bundle-and-Brewfile.md
+++ b/docs/Brew-Bundle-and-Brewfile.md
@@ -330,5 +330,3 @@ We are interested in contributions for other packages' installers/checkers/dumpe
 - be able to dump the installed software to a format that can be stored in a `Brewfile`
 - not require `sudo` to install (casks are an exception here)
 - be extremely widely used
-
-Note: based on these criteria, we would not accept e.g. Whalebrew today.
diff --git a/docs/Cask-Cookbook.md b/docs/Cask-Cookbook.md
index ca7b390caec75..e2dae6dda6f42 100644
--- a/docs/Cask-Cookbook.md
+++ b/docs/Cask-Cookbook.md
@@ -1225,7 +1225,7 @@ To adjust the installed version depending on the current macOS release, use a se
 
 ```ruby
 cask "calibre" do
-  on_high_sierra :or_older do
+  on_sonoma :or_older do
     version "3.48.0"
     sha256 "68829cd902b8e0b2b7d5cf7be132df37bcc274a1e5720b4605d2dd95f3a29168"
 
@@ -1233,13 +1233,10 @@ cask "calibre" do
       skip "Legacy version"
     end
   end
-  on_mojave do
+  on_sequoia do
     # ...
   end
-  on_catalina do
-    # ...
-  end
-  on_big_sur :or_newer do
+  on_tahoe :or_newer do
     version "6.25.0"
     sha256 "a7ed19ae0526630ccb138b9afee6dc5169904180b02f7a3089e78d3e0022753b"
 
diff --git a/docs/Formula-Cookbook.md b/docs/Formula-Cookbook.md
index ff69e214671fc..d315375b1a230 100644
--- a/docs/Formula-Cookbook.md
+++ b/docs/Formula-Cookbook.md
@@ -131,7 +131,7 @@ class Foo < Formula
   depends_on xcode: ["9.3", :build]
   depends_on arch: :x86_64
   depends_on "jpeg"
-  depends_on macos: :high_sierra
+  depends_on macos: :sonoma
   depends_on "pkgconf"
   depends_on "readline" => :recommended
   depends_on "gtk+" => :optional
@@ -696,10 +696,10 @@ on_linux do
 end
 ```
 
-Components can also be declared for specific macOS versions or version ranges. For example, to declare a dependency only on High Sierra, nest the `depends_on` call inside an `on_high_sierra` block. Add an `:or_older` or `:or_newer` parameter to the `on_high_sierra` method to add the dependency to all macOS versions that meet the condition. For example, to add `gettext` as a build dependency on Mojave and all later macOS versions, use:
+Components can also be declared for specific macOS versions or version ranges. For example, to declare a dependency only on Sequoia, nest the `depends_on` call inside an `on_sequoia` block. Add an `:or_older` or `:or_newer` parameter to the `on_sequoia` method to add the dependency to all macOS versions that meet the condition. For example, to add `gettext` as a build dependency on Sequoia and all later macOS versions, use:
 
 ```ruby
-on_mojave :or_newer do
+on_sequoia :or_newer do
   depends_on "gettext" => :build
 end
 ```
@@ -707,7 +707,7 @@ end
 Sometimes, a dependency is needed on certain macOS versions *and* on Linux. In these cases, a special `on_system` method can be used:
 
 ```ruby
-on_system :linux, macos: :sierra_or_older do
+on_system :linux, macos: :sonoma_or_older do
   depends_on "gettext" => :build
 end
 ```
@@ -728,7 +728,7 @@ Inside `def install` and `test do`, don't use these `on_*` methods. Instead, use
 
 * `OS.mac?` and `OS.linux?` return `true` or `false` based on the OS
 * `Hardware::CPU.arm?` and `Hardware::CPU.intel?` return `true` or `false` based on the arch
-* `MacOS.version` returns the current macOS version. Use `==`, `<=` or `>=` to compare to symbols corresponding to macOS versions (e.g. `if MacOS.version >= :mojave`)
+* `MacOS.version` returns the current macOS version. Use `==`, `<=` or `>=` to compare to symbols corresponding to macOS versions (e.g. `if MacOS.version >= :tahoe`)
 
 See the [`icoutils`](https://github.com/Homebrew/homebrew-core/blob/442f9cc511ce6dfe75b96b2c83749d90dde914d2/Formula/i/icoutils.rb#L36) formula for an example.
 
diff --git a/docs/Manpage.md b/docs/Manpage.md
index cfd6c474250d1..49b5d1dfc0482 100644
--- a/docs/Manpage.md
+++ b/docs/Manpage.md
@@ -137,7 +137,7 @@ and are now no longer needed.
 ### `bundle` \[*`subcommand`*\]
 
 Bundler for non-Ruby dependencies from Homebrew, Homebrew Cask, Mac App Store,
-Whalebrew, Visual Studio Code (and forks/variants) and Go packages.
+Visual Studio Code (and forks/variants) and Go packages.
 
 `brew bundle` \[`install`\]
 
@@ -149,8 +149,7 @@ You can specify the `Brewfile` location using `--file` or by setting the
 You can skip the installation of dependencies by adding space-separated values
 to one or more of the following environment variables:
 `$HOMEBREW_BUNDLE_BREW_SKIP`, `$HOMEBREW_BUNDLE_CASK_SKIP`,
-`$HOMEBREW_BUNDLE_MAS_SKIP`, `$HOMEBREW_BUNDLE_WHALEBREW_SKIP`,
-`$HOMEBREW_BUNDLE_TAP_SKIP`.
+`$HOMEBREW_BUNDLE_MAS_SKIP`, `$HOMEBREW_BUNDLE_TAP_SKIP`.
 
 `brew bundle upgrade`
 
@@ -191,14 +190,14 @@ By default, only Homebrew formula dependencies are listed.
 `brew bundle add` *`name`* \[...\]
 
 : Add entries to your `Brewfile`. Adds formulae by default. Use `--cask`,
-  `--tap`, `--whalebrew` or `--vscode` to add the corresponding entry instead.
+  `--tap` or `--vscode` to add the corresponding entry instead.
 
 `brew bundle remove` *`name`* \[...\]
 
 : Remove entries that match `name` from your `Brewfile`. Use `--formula`,
-  `--cask`, `--tap`, `--mas`, `--whalebrew` or `--vscode` to remove only entries
-  of the corresponding type. Passing `--formula` also removes matches against
-  formula aliases and old formula names.
+  `--cask`, `--tap`, `--mas` or `--vscode` to remove only entries of the
+  corresponding type. Passing `--formula` also removes matches against formula
+  aliases and old formula names.
 
 `brew bundle exec` \[`--check`\] *`command`*
 
@@ -293,10 +292,6 @@ flags which will help with finding keg-only dependencies like `openssl`,
 
 : `list` or `dump` Mac App Store dependencies.
 
-`--whalebrew`
-
-: `list` or `dump` Whalebrew dependencies.
-
 `--vscode`
 
 : `list`, `dump` or `cleanup` VSCode (and forks/variants) extensions.
@@ -3965,10 +3960,6 @@ command execution (e.g. `$(cat file)`).
   
   *Default:* `https://github.com/Homebrew/brew`.
 
-`HOMEBREW_BREW_WRAPPER`
-
-: If set, use wrapper to call `brew` rather than auto-detecting it.
-
 `HOMEBREW_BROWSER`
 
 : Use this as the browser when opening project homepages.
@@ -4350,7 +4341,8 @@ command execution (e.g. `$(cat file)`).
 
 `HOMEBREW_NO_FORCE_BREW_WRAPPER`
 
-: If set, disables `$HOMEBREW_FORCE_BREW_WRAPPER` behaviour, even if set.
+: `Deprecated:` If set, disables `$HOMEBREW_FORCE_BREW_WRAPPER` behaviour, even
+  if set.
 
 `HOMEBREW_NO_GITHUB_API`
 
diff --git a/docs/Support-Tiers.md b/docs/Support-Tiers.md
index 98c3b812c3b03..fd982b406dd83 100644
--- a/docs/Support-Tiers.md
+++ b/docs/Support-Tiers.md
@@ -120,7 +120,7 @@ As a result, Homebrew will also drop macOS Intel x86_64 support in a future rele
 
 Here's the timescale for planned future Tier support:
 
-- Today (September 2025):
+- Today (November 2025):
   - Tier 1: macOS Tahoe 26, Sequoia 15, Sonoma 14 on Apple Silicon and Intel x86_64
   - Tier 3: macOS Catalina 10.15 - Ventura 13
   - Unsupported: macOS Mojave 10.14 and earlier
diff --git a/manpages/brew.1 b/manpages/brew.1
index 717d532184065..a91dfd440145e 100644
--- a/manpages/brew.1
+++ b/manpages/brew.1
@@ -83,14 +83,14 @@ Uninstall formulae that were only installed as a dependency of another formula a
 \fB\-n\fP, \fB\-\-dry\-run\fP
 List what would be uninstalled, but do not actually uninstall anything\.
 .SS "\fBbundle\fP \fR[\fIsubcommand\fP]"
-Bundler for non\-Ruby dependencies from Homebrew, Homebrew Cask, Mac App Store, Whalebrew, Visual Studio Code (and forks/variants) and Go packages\.
+Bundler for non\-Ruby dependencies from Homebrew, Homebrew Cask, Mac App Store, Visual Studio Code (and forks/variants) and Go packages\.
 .TP
 \fBbrew bundle\fP [\fBinstall\fP]
 Install and upgrade (by default) all dependencies from the \fBBrewfile\fP\&\.
 .P
 You can specify the \fBBrewfile\fP location using \fB\-\-file\fP or by setting the \fB$HOMEBREW_BUNDLE_FILE\fP environment variable\.
 .P
-You can skip the installation of dependencies by adding space\-separated values to one or more of the following environment variables: \fB$HOMEBREW_BUNDLE_BREW_SKIP\fP, \fB$HOMEBREW_BUNDLE_CASK_SKIP\fP, \fB$HOMEBREW_BUNDLE_MAS_SKIP\fP, \fB$HOMEBREW_BUNDLE_WHALEBREW_SKIP\fP, \fB$HOMEBREW_BUNDLE_TAP_SKIP\fP\&\.
+You can skip the installation of dependencies by adding space\-separated values to one or more of the following environment variables: \fB$HOMEBREW_BUNDLE_BREW_SKIP\fP, \fB$HOMEBREW_BUNDLE_CASK_SKIP\fP, \fB$HOMEBREW_BUNDLE_MAS_SKIP\fP, \fB$HOMEBREW_BUNDLE_TAP_SKIP\fP\&\.
 .TP
 \fBbrew bundle upgrade\fP
 Shorthand for \fBbrew bundle install \-\-upgrade\fP\&\.
@@ -119,10 +119,10 @@ By default, only Homebrew formula dependencies are listed\.
 Edit the \fBBrewfile\fP in your editor\.
 .TP
 \fBbrew bundle add\fP \fIname\fP [\.\.\.]
-Add entries to your \fBBrewfile\fP\&\. Adds formulae by default\. Use \fB\-\-cask\fP, \fB\-\-tap\fP, \fB\-\-whalebrew\fP or \fB\-\-vscode\fP to add the corresponding entry instead\.
+Add entries to your \fBBrewfile\fP\&\. Adds formulae by default\. Use \fB\-\-cask\fP, \fB\-\-tap\fP or \fB\-\-vscode\fP to add the corresponding entry instead\.
 .TP
 \fBbrew bundle remove\fP \fIname\fP [\.\.\.]
-Remove entries that match \fBname\fP from your \fBBrewfile\fP\&\. Use \fB\-\-formula\fP, \fB\-\-cask\fP, \fB\-\-tap\fP, \fB\-\-mas\fP, \fB\-\-whalebrew\fP or \fB\-\-vscode\fP to remove only entries of the corresponding type\. Passing \fB\-\-formula\fP also removes matches against formula aliases and old formula names\.
+Remove entries that match \fBname\fP from your \fBBrewfile\fP\&\. Use \fB\-\-formula\fP, \fB\-\-cask\fP, \fB\-\-tap\fP, \fB\-\-mas\fP or \fB\-\-vscode\fP to remove only entries of the corresponding type\. Passing \fB\-\-formula\fP also removes matches against formula aliases and old formula names\.
 .TP
 \fBbrew bundle exec\fP [\fB\-\-check\fP] \fIcommand\fP
 Run an external command in an isolated build environment based on the \fBBrewfile\fP dependencies\.
@@ -180,9 +180,6 @@ Temporarily start services while running the \fBexec\fP or \fBsh\fP command\. En
 \fB\-\-mas\fP
 \fBlist\fP or \fBdump\fP Mac App Store dependencies\.
 .TP
-\fB\-\-whalebrew\fP
-\fBlist\fP or \fBdump\fP Whalebrew dependencies\.
-.TP
 \fB\-\-vscode\fP
 \fBlist\fP, \fBdump\fP or \fBcleanup\fP VSCode (and forks/variants) extensions\.
 .TP
@@ -2548,9 +2545,6 @@ Use this URL as the Homebrew/brew \fBgit\fP(1) remote\.
 \fIDefault:\fP \fBhttps://github\.com/Homebrew/brew\fP\&\.
 .RE
 .TP
-\fBHOMEBREW_BREW_WRAPPER\fP
-If set, use wrapper to call \fBbrew\fP rather than auto\-detecting it\.
-.TP
 \fBHOMEBREW_BROWSER\fP
 Use this as the browser when opening project homepages\.
 .RS
@@ -2839,7 +2833,7 @@ If set, do not print \fB$HOMEBREW_INSTALL_BADGE\fP on a successful build\.
 If set, do not print any hints about changing Homebrew\[u2019]s behaviour with environment variables\.
 .TP
 \fBHOMEBREW_NO_FORCE_BREW_WRAPPER\fP
-If set, disables \fB$HOMEBREW_FORCE_BREW_WRAPPER\fP behaviour, even if set\.
+\fBDeprecated:\fP If set, disables \fB$HOMEBREW_FORCE_BREW_WRAPPER\fP behaviour, even if set\.
 .TP
 \fBHOMEBREW_NO_GITHUB_API\fP
 If set, do not use the GitHub API, e\.g\. for searches or fetching relevant issues after a failed install\.