diff --git a/GNUmakefile b/GNUmakefile
index 891996b0fb..264142f536 100644
--- a/GNUmakefile
+++ b/GNUmakefile
@@ -133,13 +133,6 @@ ifdef SKIP_DOCKER_BUILD
 ENVOY_INTEG_DEPS=noop
 endif
 
-DEV_PUSH?=0
-ifeq ($(DEV_PUSH),1)
-DEV_PUSH_ARG=
-else
-DEV_PUSH_ARG=--no-push
-endif
-
 # all builds binaries for all targets
 all: bin
 
@@ -150,7 +143,7 @@ bin: tools
 	@$(SHELL) $(CURDIR)/build-support/scripts/build-local.sh
 
 # dev creates binaries for testing locally - these are put into ./bin and $GOPATH
-dev: changelogfmt dev-build
+dev: dev-build
 
 dev-build:
 	@$(SHELL) $(CURDIR)/build-support/scripts/build-local.sh -o $(GOOS) -a $(GOARCH)
@@ -181,10 +174,6 @@ ifeq ($(CIRCLE_BRANCH), main)
 	@docker push $(CI_DEV_DOCKER_NAMESPACE)/$(CI_DEV_DOCKER_IMAGE_NAME):latest
 endif
 
-changelogfmt:
-	@echo "--> Making [GH-xxxx] references clickable..."
-	@sed -E 's|([^\[])\[GH-([0-9]+)\]|\1[[GH-\2](https://github.com/hashicorp/consul/issues/\2)]|g' CHANGELOG.md > changelog.tmp && mv changelog.tmp CHANGELOG.md
-
 # linux builds a linux package independent of the source platform
 linux:
 	@$(SHELL) $(CURDIR)/build-support/scripts/build-local.sh -o linux -a amd64
@@ -193,15 +182,6 @@ linux:
 dist:
 	@$(SHELL) $(CURDIR)/build-support/scripts/release.sh -t '$(DIST_TAG)' -b '$(DIST_BUILD)' -S '$(DIST_SIGN)' $(DIST_VERSION_ARG) $(DIST_DATE_ARG) $(DIST_REL_ARG)
 
-verify:
-	@$(SHELL) $(CURDIR)/build-support/scripts/verify.sh
-
-publish:
-	@$(SHELL) $(CURDIR)/build-support/scripts/publish.sh $(PUB_GIT_ARG) $(PUB_WEBSITE_ARG)
-
-dev-tree:
-	@$(SHELL) $(CURDIR)/build-support/scripts/dev.sh $(DEV_PUSH_ARG)
-
 cover: cov
 cov: other-consul dev-build
 	go test -tags '$(GOTAGS)' ./... -coverprofile=coverage.out
@@ -400,6 +380,6 @@ envoy-regen:
 	@find "command/connect/envoy/testdata" -name '*.golden' -delete
 	@go test -tags '$(GOTAGS)' ./command/connect/envoy -update
 
-.PHONY: all ci bin dev dist cov test test-flake test-internal cover lint ui static-assets tools
+.PHONY: all bin dev dist cov test test-flake test-internal cover lint ui static-assets tools
 .PHONY: docker-images go-build-image ui-build-image static-assets-docker consul-docker ui-docker
 .PHONY: version proto test-envoy-integ
diff --git a/build-support/functions/10-util.sh b/build-support/functions/10-util.sh
index 9198e3bf14..b116f24838 100644
--- a/build-support/functions/10-util.sh
+++ b/build-support/functions/10-util.sh
@@ -268,199 +268,6 @@ function git_branch {
    return ${ret}
 }
 
-function git_upstream {
-   # Arguments:
-   #   $1 - Path to the git repo (optional - assumes pwd is git repo otherwise)
-   #
-   # Returns:
-   #   0 - success
-   #   * - failure
-   #
-   # Notes:
-   #   Echos the current upstream branch to stdout when successful
-
-   local gdir="$(pwd)"
-   if test -d "$1"
-   then
-      gdir="$1"
-   fi
-
-   pushd "${gdir}" > /dev/null
-
-   local ret=0
-   local head="$(git status -b --porcelain=v2 | awk '{if ($1 == "#" && $2 =="branch.upstream") { print $3 }}')" || ret=1
-
-   popd > /dev/null
-
-   test ${ret} -eq 0 && echo "$head"
-   return ${ret}
-}
-
-function git_log_summary {
-   # Arguments:
-   #   $1 - Path to the git repo (optional - assumes pwd is git repo otherwise)
-   #
-   # Returns:
-   #   0 - success
-   #   * - failure
-   #
-
-   local gdir="$(pwd)"
-   if test -d "$1"
-   then
-      gdir="$1"
-   fi
-
-   pushd "${gdir}" > /dev/null
-
-   local ret=0
-
-   local head=$(git_branch) || ret=1
-   local upstream=$(git_upstream) || ret=1
-   local rev_range="${head}...${upstream}"
-
-   if test ${ret} -eq 0
-   then
-      status "Git Changes:"
-      git log --pretty=oneline ${rev_range} || ret=1
-
-   fi
-   return $ret
-}
-
-function git_diff {
-   # Arguments:
-   #   $1 - Path to the git repo (optional - assumes pwd is git repo otherwise)
-   #   $2 .. $N - Optional path specification
-   #
-   # Returns:
-   #   0 - success
-   #   * - failure
-   #
-
-   local gdir="$(pwd)"
-   if test -d "$1"
-   then
-      gdir="$1"
-   fi
-
-   shift
-
-   pushd "${gdir}" > /dev/null
-
-   local ret=0
-
-   local head=$(git_branch) || ret=1
-   local upstream=$(git_upstream) || ret=1
-
-   if test ${ret} -eq 0
-   then
-      status "Git Diff - Paths: $@"
-      git diff ${HEAD} ${upstream} -- "$@" || ret=1
-   fi
-   return $ret
-}
-
-function normalize_git_url {
-   url="${1#https://}"
-   url="${url#git@}"
-   url="${url%.git}"
-   url="$(sed ${SED_EXT} -e 's/([^\/:]*)[:\/](.*)/\1:\2/' <<< "${url}")"
-   echo "$url"
-   return 0
-}
-
-function git_remote_url {
-   # Arguments:
-   #   $1 - Path to the top level Consul source
-   #   $2 - Remote name
-   #
-   # Returns:
-   #   0 - success
-   #   * - error
-   #
-   # Note:
-   #   The push url for the git remote will be echoed to stdout
-
-   if ! test -d "$1"
-   then
-      err "ERROR: '$1' is not a directory. git_remote_url must be called with the path to the top level source as the first argument'"
-      return 1
-   fi
-
-   if test -z "$2"
-   then
-      err "ERROR: git_remote_url must be called with a second argument that is the name of the remote"
-      return 1
-   fi
-
-   local ret=0
-
-   pushd "$1" > /dev/null
-
-   local url=$(git remote get-url --push $2 2>&1) || ret=1
-
-   popd > /dev/null
-
-   if test "${ret}" -eq 0
-   then
-      echo "${url}"
-      return 0
-   fi
-}
-
-function find_git_remote {
-   # Arguments:
-   #   $1 - Path to the top level Consul source
-   #
-   # Returns:
-   #   0 - success
-   #   * - error
-   #
-   # Note:
-   #   The remote name to use for publishing will be echoed to stdout upon success
-
-   if ! test -d "$1"
-   then
-      err "ERROR: '$1' is not a directory. find_git_remote must be called with the path to the top level source as the first argument'"
-      return 1
-   fi
-
-   need_url=$(normalize_git_url "${PUBLISH_GIT_HOST}:${PUBLISH_GIT_REPO}")
-   debug "Required normalized remote: ${need_url}"
-
-   pushd "$1" > /dev/null
-
-   local ret=1
-   for remote in $(git remote)
-   do
-      url=$(git remote get-url --push ${remote}) || continue
-      url=$(normalize_git_url "${url}")
-
-      debug "Testing Remote: ${remote}: ${url}"
-      if test "${url}" == "${need_url}"
-      then
-         echo "${remote}"
-         ret=0
-         break
-      fi
-   done
-
-   popd > /dev/null
-   return ${ret}
-}
-
-function git_remote_not_denylisted {
-   # Arguments:
-   #   $1 - path to the repo
-   #   $2 - the remote name
-   #
-   # Returns:
-   #   0 - not denylisted
-   #   * - denylisted
-   return 0
-}
-
 function is_git_clean {
    # Arguments:
    #   $1 - Path to git repo
@@ -516,95 +323,6 @@ function update_git_env {
    return 0
 }
 
-function git_push_ref {
-   # Arguments:
-   #   $1 - Path to the top level Consul source
-   #   $2 - Git ref (optional)
-   #   $3 - remote (optional - if not specified we will try to determine it)
-   #
-   # Returns:
-   #   0 - success
-   #   * - error
-
-   if ! test -d "$1"
-   then
-      err "ERROR: '$1' is not a directory. push_git_release must be called with the path to the top level source as the first argument'"
-      return 1
-   fi
-
-   local sdir="$1"
-   local ret=0
-   local remote="$3"
-
-   # find the correct remote corresponding to the desired repo (basically prevent pushing enterprise to oss or oss to enterprise)
-   if test -z "${remote}"
-   then
-      local remote=$(find_git_remote "${sdir}") || return 1
-      status "Using git remote: ${remote}"
-   fi
-
-   local ref=""
-
-   pushd "${sdir}" > /dev/null
-
-   if test -z "$2"
-   then
-      # If no git ref was provided we lookup the current local branch and its tracking branch
-      # It must have a tracking upstream and it must be tracking the sanctioned git remote
-      local head=$(git_branch "${sdir}") || return 1
-      local upstream=$(git_upstream "${sdir}") || return 1
-
-      # upstream branch for this branch does not track the remote we need to push to
-      # basically this checks that the upstream (could be something like origin/main) references the correct remote
-      # if it doesn't then the string modification wont apply and the var will reamin unchanged and equal to itself.
-      if test "${upstream#${remote}/}" == "${upstream}"
-      then
-         err "ERROR: Upstream branch '${upstream}' does not track the correct remote '${remote}' - cannot push"
-         ret=1
-      fi
-      ref="refs/heads/${head}"
-   else
-      # A git ref was provided - get the full ref and make sure it isn't ambiguous and also to
-      # be able to determine whether its a branch or tag we are pushing
-      ref_out=$(git rev-parse --symbolic-full-name "$2" --)
-
-      # -ne 2 because it should have the ref on one line followed by a line with '--'
-      if test "$(wc -l <<< "${ref_out}")" -ne 2
-      then
-         err "ERROR: Git ref '$2' is ambiguous"
-         debug "${ref_out}"
-         ret=1
-      else
-         ref=$(head -n 1 <<< "${ref_out}")
-      fi
-   fi
-
-   if test ${ret} -eq 0
-   then
-      case "${ref}" in
-         refs/tags/*)
-            status "Pushing tag ${ref#refs/tags/} to ${remote}"
-            ;;
-         refs/heads/*)
-            status "Pushing local branch ${ref#refs/tags/} to ${remote}"
-            ;;
-         *)
-            err "ERROR: git_push_ref func is refusing to push ref that isn't a branch or tag"
-            return 1
-      esac
-
-      if ! git push "${remote}" "${ref}"
-      then
-         err "ERROR: Failed to push ${ref} to remote: ${remote}"
-         ret=1
-      fi
-   fi
-
-   popd > /dev/null
-
-   return $ret
-}
-
 function update_version {
    # Arguments:
    #   $1 - Path to the version file
@@ -718,39 +436,6 @@ function unset_changelog_version {
    return $?
 }
 
-function add_unreleased_to_changelog {
-   # Arguments:
-   #   $1 - Path to top level Consul source
-   #
-   # Returns:
-   #   0 - success
-   #   * - error
-
-   local changelog="${1}/CHANGELOG.md"
-
-   if ! test -f "${changelog}"
-   then
-      err "ERROR: File not found: ${changelog}"
-      return 1
-   fi
-
-   # Check if we are already in unreleased mode
-   if head -n 1 "${changelog}" | grep -q -c UNRELEASED
-   then
-      return 0
-   fi
-
-   local tfile="$(mktemp) -t "CHANGELOG.md_")"
-   (
-      echo -e "## UNRELEASED\n" > "${tfile}" &&
-      cat "${changelog}" >> "${tfile}" &&
-      cp "${tfile}" "${changelog}"
-   )
-   local ret=$?
-   rm "${tfile}"
-   return $ret
-}
-
 function set_release_mode {
    # Arguments:
    #   $1 - Path to top level Consul source
@@ -814,99 +499,6 @@ function set_release_mode {
    return 0
 }
 
-function set_dev_mode {
-   # Arguments:
-   #   $1 - Path to top level Consul source
-   #
-   # Returns:
-   #   0 - success
-   #   * - error
-
-   if ! test -d "$1"
-   then
-      err "ERROR: '$1' is not a directory. set_dev_mode must be called with the path to a git repo as the first argument'"
-      return 1
-   fi
-
-   local sdir="$1"
-   local vers="$(parse_version "${sdir}" false false)"
-
-   status_stage "==> Setting VersionPreRelease back to 'dev'"
-   update_version "${sdir}/version/version.go" "${vers}" dev || return 1
-
-   status_stage "==> Adding new UNRELEASED label in CHANGELOG.md"
-   add_unreleased_to_changelog "${sdir}" || return 1
-
-   return 0
-}
-
-function git_staging_empty {
-   # Arguments:
-   #   $1 - Path to git repo
-   #
-   # Returns:
-   #   0 - success (nothing staged)
-   #   * - error (staged files)
-
-   if ! test -d "$1"
-   then
-      err "ERROR: '$1' is not a directory. commit_dev_mode must be called with the path to a git repo as the first argument'"
-      return 1
-   fi
-
-   pushd "$1" > /dev/null
-
-   declare -i ret=0
-
-   for status in $(git status --porcelain=v2 | awk '{print $2}' | cut -b 1)
-   do
-      if test "${status}" != "."
-      then
-         ret=1
-         break
-      fi
-   done
-
-   popd > /dev/null
-   return ${ret}
-}
-
-function commit_dev_mode {
-   # Arguments:
-   #   $1 - Path to top level Consul source
-   #
-   # Returns:
-   #   0 - success
-   #   * - error
-
-   if ! test -d "$1"
-   then
-      err "ERROR: '$1' is not a directory. commit_dev_mode must be called with the path to a git repo as the first argument'"
-      return 1
-   fi
-
-   status "Checking for previously staged files"
-   git_staging_empty "$1" || return 1
-
-   declare -i ret=0
-
-   pushd "$1" > /dev/null
-
-   status "Staging CHANGELOG.md and version_*.go files"
-   git add CHANGELOG.md && git add version/version*.go
-   ret=$?
-
-   if test ${ret} -eq 0
-   then
-      status "Adding Commit"
-      git commit -m "Putting source back into Dev Mode"
-      ret=$?
-   fi
-
-   popd >/dev/null
-   return ${ret}
-}
-
 function gpg_detach_sign {
    # Arguments:
    #   $1 - File to sign
diff --git a/build-support/functions/40-publish.sh b/build-support/functions/40-publish.sh
deleted file mode 100644
index c1ed2be0a2..0000000000
--- a/build-support/functions/40-publish.sh
+++ /dev/null
@@ -1,423 +0,0 @@
-function hashicorp_release {
-   # Arguments:
-   #   $1 - Path to directory containing all of the release artifacts
-   #
-   # Returns:
-   #   0 - success
-   #   * - failure
-   #
-   # Notes:
-   #   Requires the AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables
-   #   to be set
-   
-   status "Uploading files"
-   hc-releases upload "${1}" || return 1
-   
-   status "Publishing the release"
-   hc-releases publish || return 1
-   
-   return 0
-}
-
-function confirm_git_remote {
-   # Arguments:
-   #   $1 - Path to git repo
-   #   $2 - remote name
-   #
-   # Returns:
-   #   0 - success
-   #   * - error
-   #
-   
-   local remote="$2"
-   local url=$(git_remote_url "$1" "${remote}")
-   
-   echo -e "\n\nConfigured Git Remote: ${remote}"
-   echo -e     "Configured Git URL:    ${url}\n"
-   
-   local answer=""
-      
-   while true
-   do
-      case "${answer}" in
-         [yY]* )
-            status "Remote Accepted"
-            return 0
-            break
-            ;;
-         [nN]* )
-            err "Remote Rejected"
-            return 1
-            break
-            ;;
-         * )
-            read -p "Is this Git Remote correct to push ${CONSUL_PKG_NAME} to? [y/n]: " answer
-            ;;
-      esac
-   done
-}
-
-function confirm_git_push_changes {
-   # Arguments:
-   #   $1 - Path to git repo
-   #
-   # Returns:
-   #   0 - success
-   #   * - error
-   #
-   
-   if ! test -d "$1"
-   then
-      err "ERROR: '$1' is not a directory. confirm_git_push_changes must be called with the path to a git repo as the first argument'" 
-      return 1
-   fi
-   
-   pushd "${1}" > /dev/null
-   
-   
-   declare -i ret=0
-   git_log_summary || ret=1
-   if test ${ret} -eq 0
-   then
-      # put a empty line between the git changes and the prompt
-      echo ""
-      
-      local answer=""
-      
-      while true
-      do
-         case "${answer}" in
-            [yY]* )
-               status "Changes Accepted"
-               ret=0
-               break
-               ;;
-            [nN]* )
-               err "Changes Rejected"
-               ret=1
-               break
-               ;;
-            ?)
-               # bindata_assetfs.go will make these meaningless
-               git_diff "$(pwd)" ":!agent/uiserver/bindata_assetfs.go"|| ret 1
-               answer=""
-               ;;
-            * )
-               read -p "Are these changes correct? [y/n] (or type ? to show the diff output): " answer
-               ;;
-         esac
-      done
-   fi
-   
-   popd > /dev/null
-   return $ret
-}
-
-function extract_consul_local {
-   # Arguments:
-   #   $1 - Path to the zipped binary to test
-   #   $2 - Version to look for
-   #
-   # Returns:
-   #   0 - success
-   #   * - error
-   
-   local zfile="${1}/${CONSUL_PKG_NAME}_${2}_$(go env GOOS)_$(go env GOARCH).zip"
-   
-   if ! test -f "${zfile}"
-   then
-      err "ERROR: File not found or is not a regular file: ${zfile}"
-      return 1
-   fi
-   
-   local ret=0
-   local tfile="$(mktemp) -t "${CONSUL_PKG_NAME}_")"
-   
-   unzip -p "${zfile}" "consul" > "${tfile}"
-   if test $? -eq 0
-   then
-      chmod +x "${tfile}"
-      echo "${tfile}"
-      return 0
-   else
-      err "ERROR: Failed to extract consul binary from the zip file"
-      return 1
-   fi
-}
-
-function confirm_consul_version {
-   # Arguments:
-   #   $1 - consul exe to use
-   # 
-   # Returns:
-   #   0 - success
-   #   * - error
-   local consul_exe="$1"
-   
-   if ! test -x "${consul_exe}"
-   then
-      err "ERROR: '${consul_exe} is not an executable"
-      return 1
-   fi
-   
-   "${consul_exe}" version
-   
-   # put a empty line between the version output and the prompt
-   echo ""
-   
-   local answer=""
-   
-   while true
-   do
-      case "${answer}" in
-         [yY]* )
-            status "Version Accepted"
-            ret=0
-            break
-            ;;
-         [nN]* )
-            err "Version Rejected"
-            ret=1
-            break
-            ;;
-         * )
-            read -p "Is this Consul version correct? [y/n]: " answer
-            ;;
-      esac
-   done
-}
-
-function confirm_consul_info {
-   # Arguments:
-   #   $1 - Path to a consul exe that can be run on this system
-   #
-   # Returns:
-   #   0 - success
-   #   * - error
-   
-   local consul_exe="$1"
-   local log_file="$(mktemp) -t "consul_log_")"
-   "${consul_exe}" agent -dev > "${log_file}" 2>&1 &
-   local consul_pid=$!
-   sleep 1
-   status "First 25 lines/1s of the agents output:"
-   head -n 25 "${log_file}"
-   
-   echo ""
-   local ret=0
-   local answer=""
-   
-   while true
-   do
-      case "${answer}" in
-         [yY]* )
-            status "Consul Agent Output Accepted"
-            break
-            ;;
-         [nN]* )
-            err "Consul Agent Output Rejected"
-            ret=1
-            break
-            ;;
-         * )
-            read -p "Is this Consul Agent Output correct? [y/n]: " answer
-            ;;
-      esac
-   done
-   
-   if test "${ret}" -eq 0
-   then
-      status "Consul Info Output"
-      "${consul_exe}" info
-      echo ""
-      local answer=""
-      
-      while true
-      do
-         case "${answer}" in
-            [yY]* )
-               status "Consul Info Output Accepted"
-               break
-               ;;
-            [nN]* )
-               err "Consul Info Output Rejected"
-               return 1
-               break
-               ;;
-            * )
-               read -p "Is this Consul Info Output correct? [y/n]: " answer
-               ;;
-         esac
-      done
-   fi
-   
-   if test "${ret}" -eq 0
-   then
-      local tfile="$(mktemp) -t "${CONSUL_PKG_NAME}_")"
-      if ! curl -o "${tfile}" "http://localhost:8500/ui/"
-      then
-         err "ERROR: Failed to curl http://localhost:8500/ui/"
-         return 1
-      fi
-      
-      local ui_vers=$(ui_version "${tfile}")
-      if test $? -ne 0
-      then
-         err "ERROR: Failed to determine the ui version from the index.html file"
-         return 1
-      fi
-      status "UI Version: ${ui_vers}"
-      local ui_logo_type=$(ui_logo_type "${tfile}")
-      if test $? -ne 0
-      then
-         err "ERROR: Failed to determine the ui logo/binary type from the index.html file"
-         return 1
-      fi
-      status "UI Logo: ${ui_logo_type}"
-      
-      echo ""
-      local answer=""
-      
-      while true
-      do
-         case "${answer}" in
-            [yY]* )
-               status "Consul UI/Logo Version Accepted"
-               break
-               ;;
-            [nN]* )
-               err "Consul UI/Logo Version Rejected"
-               return 1
-               break
-               ;;
-            * )
-               read -p "Is this Consul UI/Logo Version correct? [y/n]: " answer
-               ;;
-         esac
-      done
-   fi
-   
-
-   
-   status "Requesting Consul to leave the cluster / shutdown"
-   "${consul_exe}" leave
-   wait ${consul_pid} > /dev/null 2>&1
-   
-   return $?
-}
-
-function extract_consul {
-   extract_consul_local "$1" "$2"
-}
-
-function verify_release_build {
-   # Arguments:
-   #   $1 - Path to top level Consul source
-   #   $2 - expected version (optional - will parse if empty)
-   #
-   # Returns:
-   #   0 - success
-   #   * - failure
-   
-   if ! test -d "$1"
-   then
-      err "ERROR: '$1' is not a directory. publish_release must be called with the path to the top level source as the first argument'" 
-      return 1
-   fi
-   
-   local sdir="$1"
-   
-   local vers="$(get_version ${sdir} true false)"
-   if test -n "$2"
-   then
-      vers="$2"
-   fi
-   
-   if test -z "${vers}"
-   then
-      err "Please specify a version (couldn't parse one from the source)." 
-      return 1
-   fi
-   
-   status_stage "==> Verifying release files"
-   check_release "${sdir}/pkg/dist" "${vers}" true || return 1
-   
-   status_stage "==> Extracting Consul version for local system"
-   local consul_exe=$(extract_consul "${sdir}/pkg/dist" "${vers}") || return 1
-   # make sure to remove the temp file
-   trap "rm '${consul_exe}'" EXIT
-   
-   status_stage "==> Confirming Consul Version"
-   confirm_consul_version "${consul_exe}" || return 1
-   
-   status_stage "==> Confirming Consul Agent Info"
-   confirm_consul_info "${consul_exe}" || return 1
-}
-
-function publish_release {
-   # Arguments:
-   #   $1 - Path to top level Consul source that contains the built release
-   #   $2 - boolean whether to publish to git upstream
-   #   $3 - boolean whether to publish to releases.hashicorp.com
-   #
-   # Returns:
-   #   0 - success
-   #   * - error
-   
-   if ! test -d "$1"
-   then
-      err "ERROR: '$1' is not a directory. publish_release must be called with the path to the top level source as the first argument'" 
-      return 1
-   fi
-   
-   local sdir="$1"
-   local pub_git="$2"
-   local pub_hc_releases="$3"
-   
-   if test -z "${pub_git}"
-   then
-      pub_git=1
-   fi
-   
-   if test -z "${pub_hc_releases}"
-   then
-      pub_hc_releases=1
-   fi
-   
-   local vers="$(get_version ${sdir} true false)"
-   if test $? -ne 0
-   then
-      err "Please specify a version (couldn't parse one from the source)." 
-      return 1
-   fi
-   
-   verify_release_build "$1" "${vers}" || return 1
-   
-   status_stage "==> Confirming Git is clean"
-   is_git_clean "$1" true || return 1
-
-   status_stage "==> Confirming Git Changes"
-   confirm_git_push_changes "$1" || return 1
-   
-   status_stage "==> Checking for denylisted Git Remote"
-   local remote=$(find_git_remote "${sdir}") || return 1
-   git_remote_not_denylisted "${sdir}" "${remote}" || return 1
-   
-   status_stage "==> Confirming Git Remote"
-   confirm_git_remote "${sdir}" "${remote}" || return 1
-   
-   if is_set "${pub_git}"
-   then
-      status_stage "==> Pushing to Git"
-      git_push_ref "$1" "" "${remote}" || return 1
-      git_push_ref "$1" "v${vers}" "${remote}" || return 1
-   fi
-   
-   if is_set "${pub_hc_releases}"
-   then
-      status_stage "==> Publishing to releases.hashicorp.com"
-      hashicorp_release "${sdir}/pkg/dist" || return 1
-   fi
-   
-   return 0
-}
diff --git a/build-support/scripts/dev.sh b/build-support/scripts/dev.sh
deleted file mode 100755
index 12a2e88492..0000000000
--- a/build-support/scripts/dev.sh
+++ /dev/null
@@ -1,108 +0,0 @@
-#!/bin/bash
-SCRIPT_NAME="$(basename ${BASH_SOURCE[0]})"
-pushd $(dirname ${BASH_SOURCE[0]}) > /dev/null
-SCRIPT_DIR=$(pwd)
-pushd ../.. > /dev/null
-SOURCE_DIR=$(pwd)
-popd > /dev/null
-pushd ../functions > /dev/null
-FN_DIR=$(pwd)
-popd > /dev/null
-popd > /dev/null
-
-source "${SCRIPT_DIR}/functions.sh"
-
-function usage {
-cat <<-EOF
-Usage: ${SCRIPT_NAME} [<options ...>]
-
-Description:
-
-   This script will put the source back into dev mode after a release.
-
-Options:
-                       
-   -s | --source     DIR         Path to source to build.
-                                 Defaults to "${SOURCE_DIR}"
-                                 
-   --no-git                      Do not commit or attempt to push
-                                 the changes back to the upstream.
-                                 
-   -h | --help                   Print this help text.
-EOF
-}
-
-function err_usage {
-   err "$1"
-   err ""
-   err "$(usage)"
-}
-
-function main {
-   declare    sdir="${SOURCE_DIR}"
-   declare    build_os=""
-   declare    build_arch=""
-   declare -i do_git=1
-   declare -i do_push=1
-   
-   
-   while test $# -gt 0
-   do
-      case "$1" in
-         -h | --help )
-            usage
-            return 0
-            ;;
-         -s | --source )
-            if test -z "$2"
-            then
-               err_usage "ERROR: option -s/--source requires an argument"
-               return 1
-            fi
-            
-            if ! test -d "$2"
-            then
-               err_usage "ERROR: '$2' is not a directory and not suitable for the value of -s/--source"
-               return 1
-            fi
-            
-            sdir="$2"
-            shift 2
-            ;;
-         --no-git )
-            do_git=0
-            shift
-            ;;
-         --no-push )
-            do_push=0
-            shift
-            ;;
-         * )
-            err_usage "ERROR: Unknown argument: '$1'"
-            return 1
-            ;;
-      esac
-   done
-   
-   set_dev_mode "${sdir}" || return 1
-   
-   if is_set "${do_git}"
-   then
-      status_stage "==> Commiting Dev Mode Changes"
-      commit_dev_mode "${sdir}" || return 1
-      
-      if is_set "${do_push}"
-      then
-         status_stage "==> Confirming Git Changes"
-         confirm_git_push_changes "${sdir}" || return 1
-         
-         status_stage "==> Pushing to Git"
-         git_push_ref "${sdir}" || return 1
-      fi
-   fi
-   
-   return 0
-}
-
-main "$@"
-exit $?
\ No newline at end of file
diff --git a/build-support/scripts/publish.sh b/build-support/scripts/publish.sh
deleted file mode 100755
index 3d6faf01f2..0000000000
--- a/build-support/scripts/publish.sh
+++ /dev/null
@@ -1,94 +0,0 @@
-#!/bin/bash
-SCRIPT_NAME="$(basename ${BASH_SOURCE[0]})"
-pushd $(dirname ${BASH_SOURCE[0]}) > /dev/null
-SCRIPT_DIR=$(pwd)
-pushd ../.. > /dev/null
-SOURCE_DIR=$(pwd)
-popd > /dev/null
-pushd ../functions > /dev/null
-FN_DIR=$(pwd)
-popd > /dev/null
-popd > /dev/null
-
-source "${SCRIPT_DIR}/functions.sh"
-
-function usage {
-cat <<-EOF
-Usage: ${SCRIPT_NAME}  [<options ...>]
-
-Description:
-
-   This script will "publish" a Consul release. It expects a prebuilt release in 
-   pkg/dist matching the version in the repo and a clean git status. It will 
-   prompt you to confirm the consul version and git changes you are going to 
-   publish prior to pushing to git and to releases.hashicorp.com.
-
-Options:                       
-   -s | --source     DIR         Path to source to build.
-                                 Defaults to "${SOURCE_DIR}"
-                                 
-   -w | --website                Publish to releases.hashicorp.com
-   
-   -g | --git                    Push release commit and tag to Git
-   
-   -h | --help                   Print this help text.
-EOF
-}
-
-function err_usage {
-   err "$1"
-   err ""
-   err "$(usage)"
-}
-
-function main {
-   declare    sdir="${SOURCE_DIR}"
-   declare -i website=0
-   declare -i git_push=0
-   
-   while test $# -gt 0
-   do
-      case "$1" in
-         -h | --help )
-            usage
-            return 0
-            ;;
-         -s | --source )
-            if test -z "$2"
-            then
-               err_usage "ERROR: option -s/--source requires an argument"
-               return 1
-            fi
-            
-            if ! test -d "$2"
-            then
-               err_usage "ERROR: '$2' is not a directory and not suitable for the value of -s/--source"
-               return 1
-            fi
-            
-            sdir="$2"
-            shift 2
-            ;;
-        -w | --website )
-            website=1
-            shift
-            ;;
-         -g | --git )
-            git_push=1
-            shift
-            ;;
-         *)
-            err_usage "ERROR: Unknown argument: '$1'"
-            return 1
-            ;;
-      esac
-   done
-   
-   publish_release "${sdir}" "${git_push}" "${website}" || return 1
-   
-   return 0
-}
-
-main "$@"
-exit $?
-   
\ No newline at end of file
diff --git a/build-support/scripts/verify.sh b/build-support/scripts/verify.sh
deleted file mode 100755
index c1678bd1a3..0000000000
--- a/build-support/scripts/verify.sh
+++ /dev/null
@@ -1,96 +0,0 @@
-#!/bin/bash
-SCRIPT_NAME="$(basename ${BASH_SOURCE[0]})"
-pushd $(dirname ${BASH_SOURCE[0]}) > /dev/null
-SCRIPT_DIR=$(pwd)
-pushd ../.. > /dev/null
-SOURCE_DIR=$(pwd)
-popd > /dev/null
-pushd ../functions > /dev/null
-FN_DIR=$(pwd)
-popd > /dev/null
-popd > /dev/null
-
-source "${SCRIPT_DIR}/functions.sh"
-
-function usage {
-cat <<-EOF
-Usage: ${SCRIPT_NAME}  [<options ...>]
-
-Description:
-
-   This script will verify a Consul release build. It will check for prebuilt
-   files, verify shasums and gpg signatures as well as run some commands
-   and prompt for manual verification where required.
-
-Options:                       
-   -s | --source     DIR         Path to source to build.
-                                 Defaults to "${SOURCE_DIR}"
-   
-   -h | --help                   Print this help text.
-EOF
-}
-
-function err_usage {
-   err "$1"
-   err ""
-   err "$(usage)"
-}
-
-function main {
-   declare    sdir="${SOURCE_DIR}" 
-   declare    vers=""
-   
-   while test $# -gt 0
-   do
-      case "$1" in
-         -h | --help )
-            usage
-            return 0
-            ;;
-         -s | --source )
-            if test -z "$2"
-            then
-               err_usage "ERROR: option -s/--source requires an argument"
-               return 1
-            fi
-            
-            if ! test -d "$2"
-            then
-               err_usage "ERROR: '$2' is not a directory and not suitable for the value of -s/--source"
-               return 1
-            fi
-            
-            sdir="$2"
-            shift 2
-            ;;
-         -v | --version )
-            if test -z "$2"
-            then
-               err_usage "ERROR: option -v/--version requires an argument"
-               return 1
-            fi
-            
-            vers="$2"
-            shift 2
-            ;;
-         *)
-            err_usage "ERROR: Unknown argument: '$1'"
-            return 1
-            ;;
-      esac
-   done
-   
-   if test -z "${vers}"
-   then
-      vers=$(parse_version "${sdir}" true false)
-   fi
-   
-   status_stage "=> Starting release verification for version: ${version}"
-   verify_release_build "${sdir}" "${vers}" || return 1
-   
-   return 0
-}
-
-main "$@"
-exit $?
-   
\ No newline at end of file