diff --git a/plugins/common/archive-functions b/plugins/common/archive-functions
index 9ed12ccc9..60dd2c1c1 100755
--- a/plugins/common/archive-functions
+++ b/plugins/common/archive-functions
@@ -11,12 +11,12 @@ fi
 DOKKU_ARCHIVE_MAX_SIZE_DEFAULT="1073741824"
 DOKKU_ARCHIVE_MAX_FILES_DEFAULT="10000"
 
-fn-archive-max-size() {
+fn-archive-computed-max-size() {
   declare desc="returns the configured max archive size in bytes"
   fn-plugin-property-get "git" "--global" "archive-max-size" "$DOKKU_ARCHIVE_MAX_SIZE_DEFAULT"
 }
 
-fn-archive-max-files() {
+fn-archive-computed-max-files() {
   declare desc="returns the configured max archive entry count"
   fn-plugin-property-get "git" "--global" "archive-max-files" "$DOKKU_ARCHIVE_MAX_FILES_DEFAULT"
 }
@@ -43,8 +43,8 @@ fn-archive-check-bomb-protection() {
   declare desc="validates archive against bomb protection limits"
   declare ARCHIVE_PATH="$1" ARCHIVE_TYPE="$2"
   local MAX_SIZE MAX_FILES
-  MAX_SIZE="$(fn-archive-max-size)"
-  MAX_FILES="$(fn-archive-max-files)"
+  MAX_SIZE="$(fn-archive-computed-max-size)"
+  MAX_FILES="$(fn-archive-computed-max-files)"
 
   local ARCHIVE_SIZE
   ARCHIVE_SIZE="$(stat -c %s "$ARCHIVE_PATH" 2>/dev/null || stat -f %z "$ARCHIVE_PATH" 2>/dev/null || echo 0)"
@@ -190,8 +190,8 @@ fn-archive-extract-zip() {
   declare desc="safely extracts a zip archive with post-extraction symlink validation"
   declare ARCHIVE_PATH="$1" DEST_DIR="$2"
   local MAX_SIZE MAX_FILES
-  MAX_SIZE="$(fn-archive-max-size)"
-  MAX_FILES="$(fn-archive-max-files)"
+  MAX_SIZE="$(fn-archive-computed-max-size)"
+  MAX_FILES="$(fn-archive-computed-max-files)"
 
   local ARCHIVE_SIZE
   ARCHIVE_SIZE="$(stat -c %s "$ARCHIVE_PATH" 2>/dev/null || stat -f %z "$ARCHIVE_PATH" 2>/dev/null || echo 0)"
diff --git a/plugins/git/functions b/plugins/git/functions
index 764942437..9c9b9206c 100755
--- a/plugins/git/functions
+++ b/plugins/git/functions
@@ -65,7 +65,7 @@ cmd-git-hook() {
 
   plugn trigger app-exists "$APP" 2>/dev/null || is_valid_app_name "$APP"
 
-  DOKKU_DEPLOY_BRANCH="$(fn-git-deploy-branch "$APP")"
+  DOKKU_DEPLOY_BRANCH="$(fn-git-computed-deploy-branch "$APP")"
   if ! git check-ref-format --branch "$DOKKU_DEPLOY_BRANCH" &>/dev/null; then
     echo $'\e[1G\e[K'"-----> WARNING: Invalid branch name '$DOKKU_DEPLOY_BRANCH' specified via deploy-branch setting."
     echo $'\e[1G\e[K'"-----> For more details, please see the man page for 'git-check-ref-format.'"
@@ -84,7 +84,7 @@ cmd-git-hook() {
       if [[ $(find "$PLUGIN_PATH"/enabled/*/receive-branch 2>/dev/null | wc -l) != 1 ]]; then
         plugn trigger receive-branch "$APP" "$newrev" "$refname"
         plugn trigger deploy-source-set "$APP" "git-push" "$newrev"
-      elif [[ -z "$(fn-git-deploy-branch "$APP" "")" ]]; then
+      elif [[ -z "$(fn-git-computed-deploy-branch "$APP" "")" ]]; then
         local deploy_branch="${refname/refs\/heads\//}"
         deploy_branch="${deploy_branch/refs\/tags\//}"
 
@@ -115,7 +115,7 @@ git_build() {
     fi
     local REF="$REV"
   else
-    DOKKU_DEPLOY_BRANCH="$(fn-git-deploy-branch "$APP")"
+    DOKKU_DEPLOY_BRANCH="$(fn-git-computed-deploy-branch "$APP")"
     if [[ -f "$DOKKU_ROOT/$APP/refs/heads/$DOKKU_DEPLOY_BRANCH" ]]; then
       REF=$(<"$DOKKU_ROOT/$APP/refs/heads/$DOKKU_DEPLOY_BRANCH")
     else
diff --git a/plugins/git/git-deploy-branch b/plugins/git/git-deploy-branch
index 3ec00749b..f0f5e50fd 100755
--- a/plugins/git/git-deploy-branch
+++ b/plugins/git/git-deploy-branch
@@ -8,7 +8,7 @@ trigger-git-git-deploy-branch() {
   declare trigger="git-deploy-branch"
   declare APP="$1"
 
-  fn-git-deploy-branch "$APP"
+  fn-git-computed-deploy-branch "$APP"
 }
 
 trigger-git-git-deploy-branch "$@"
diff --git a/plugins/git/git-from-directory b/plugins/git/git-from-directory
index 238fb297b..87dddadd3 100755
--- a/plugins/git/git-from-directory
+++ b/plugins/git/git-from-directory
@@ -11,7 +11,7 @@ trigger-git-git-from-directory() {
   declare APP="$1" SOURCECODE_WORK_DIR="$2" USER_NAME="${3:-Dokku}" USER_EMAIL="${4:-automated@dokku.sh}"
 
   local APP_ROOT="$DOKKU_ROOT/$APP"
-  local DOKKU_DEPLOY_BRANCH="$(fn-git-deploy-branch "$APP")"
+  local DOKKU_DEPLOY_BRANCH="$(fn-git-computed-deploy-branch "$APP")"
   local REV
   local TMP_WORK_DIR=$(mktemp -d "/tmp/dokku-${DOKKU_PID}-${FUNCNAME[0]}.XXXXXX")
   local TMP_WORK_DIR_2=$(mktemp -d "/tmp/dokku-${DOKKU_PID}-${FUNCNAME[0]}.XXXXXX")
@@ -25,7 +25,7 @@ trigger-git-git-from-directory() {
   dokku_log_info1 "Updating git repository with specified build context"
   if [[ "$has_code" == "false" ]]; then
     # setup new repo
-    local DEPLOY_BRANCH="$(fn-git-deploy-branch "$APP")"
+    local DEPLOY_BRANCH="$(fn-git-computed-deploy-branch "$APP")"
     cp -rT "$SOURCECODE_WORK_DIR" "$TMP_WORK_DIR"
     suppress_output fn-git-cmd "$TMP_WORK_DIR" init
     suppress_output fn-git-cmd "$TMP_WORK_DIR" checkout -b "$DEPLOY_BRANCH"
@@ -64,7 +64,7 @@ trigger-git-git-from-directory() {
     return
   else
     local exit_code=$?
-    local DOKKU_DEPLOY_BRANCH="$(fn-git-deploy-branch "$APP")"
+    local DOKKU_DEPLOY_BRANCH="$(fn-git-computed-deploy-branch "$APP")"
     if [[ "$has_code" == "false" ]]; then
       fn-git-cmd "$APP_ROOT" update-ref -d HEAD
     else
diff --git a/plugins/git/internal-functions b/plugins/git/internal-functions
index f705cd160..916c70ca5 100755
--- a/plugins/git/internal-functions
+++ b/plugins/git/internal-functions
@@ -274,7 +274,7 @@ cmd-git-sync() {
   fi
 
   local APP_ROOT="$DOKKU_ROOT/$APP"
-  DOKKU_DEPLOY_BRANCH="$(fn-git-deploy-branch "$APP")"
+  DOKKU_DEPLOY_BRANCH="$(fn-git-computed-deploy-branch "$APP")"
   CURRENT_REF="$(fn-git-cmd "$APP_ROOT" rev-parse "$DOKKU_DEPLOY_BRANCH" 2>/dev/null || true)"
 
   dokku_setup_build_capture "$APP" "git:sync"
@@ -370,10 +370,10 @@ cmd-git-report-single() {
   local flag_map=()
   if [[ "$APP" == "--global" ]]; then
     flag_map=(
-      "--git-computed-archive-max-files: $(fn-archive-max-files)"
-      "--git-computed-archive-max-size: $(fn-archive-max-size)"
-      "--git-computed-deploy-branch: $(fn-git-deploy-branch "$APP")"
-      "--git-computed-keep-git-dir: $(fn-git-keep-git-dir "$APP")"
+      "--git-computed-archive-max-files: $(fn-archive-computed-max-files)"
+      "--git-computed-archive-max-size: $(fn-archive-computed-max-size)"
+      "--git-computed-deploy-branch: $(fn-git-computed-deploy-branch "$APP")"
+      "--git-computed-keep-git-dir: $(fn-git-computed-keep-git-dir "$APP")"
       "--git-global-archive-max-files: $(fn-plugin-property-get "git" "--global" "archive-max-files" "")"
       "--git-global-archive-max-size: $(fn-plugin-property-get "git" "--global" "archive-max-size" "")"
       "--git-global-deploy-branch: $(fn-plugin-property-get "git" "--global" "deploy-branch" "")"
@@ -382,10 +382,10 @@ cmd-git-report-single() {
   else
     verify_app_name "$APP"
     flag_map=(
-      "--git-computed-archive-max-files: $(fn-archive-max-files)"
-      "--git-computed-archive-max-size: $(fn-archive-max-size)"
-      "--git-computed-deploy-branch: $(fn-git-deploy-branch "$APP")"
-      "--git-computed-keep-git-dir: $(fn-git-keep-git-dir "$APP")"
+      "--git-computed-archive-max-files: $(fn-archive-computed-max-files)"
+      "--git-computed-archive-max-size: $(fn-archive-computed-max-size)"
+      "--git-computed-deploy-branch: $(fn-git-computed-deploy-branch "$APP")"
+      "--git-computed-keep-git-dir: $(fn-git-computed-keep-git-dir "$APP")"
       "--git-deploy-branch: $(fn-plugin-property-get "git" "$APP" "deploy-branch" "")"
       "--git-global-archive-max-files: $(fn-plugin-property-get "git" "--global" "archive-max-files" "")"
       "--git-global-archive-max-size: $(fn-plugin-property-get "git" "--global" "archive-max-size" "")"
@@ -484,13 +484,13 @@ fn-git-clone() {
   local APP_ROOT="$DOKKU_ROOT/$APP"
   [[ -z "$APP" ]] && dokku_log_fail "Please specify an app to run the command on"
 
-  local DOKKU_DEPLOY_BRANCH="$(fn-git-deploy-branch "$APP")"
+  local DOKKU_DEPLOY_BRANCH="$(fn-git-computed-deploy-branch "$APP")"
   if fn-git-cmd "$APP_ROOT" rev-parse "$DOKKU_DEPLOY_BRANCH" &>/dev/null; then
     dokku_log_fail "The clone subcommand can only be executed for new applications"
   fi
 
   if [[ -z "$GIT_REF" ]]; then
-    GIT_REF="$(fn-git-deploy-branch "$APP")"
+    GIT_REF="$(fn-git-computed-deploy-branch "$APP")"
   fi
 
   local TMP_IS_REF_DIR=$(mktemp -d "/tmp/dokku-ref-${DOKKU_PID}-${FUNCNAME[0]}.XXXXXX")
@@ -520,7 +520,7 @@ fn-git-clone() {
     fi
   fi
 
-  DOKKU_DEPLOY_BRANCH="$(fn-git-deploy-branch "$APP")"
+  DOKKU_DEPLOY_BRANCH="$(fn-git-computed-deploy-branch "$APP")"
   if [[ "$GIT_REF" != "$DOKKU_DEPLOY_BRANCH" ]]; then
     if [[ "$is_ref" == "true" ]]; then
       fn-git-cmd "$TMP_CLONE_DIR" branch -qq -D "$DOKKU_DEPLOY_BRANCH" 2>/dev/null || true
@@ -551,12 +551,12 @@ fn-git-fetch() {
   local DOKKU_DEPLOY_BRANCH
   local APP_ROOT="$DOKKU_ROOT/$APP"
 
-  local DOKKU_DEPLOY_BRANCH="$(fn-git-deploy-branch "$APP")"
+  local DOKKU_DEPLOY_BRANCH="$(fn-git-computed-deploy-branch "$APP")"
   if ! fn-git-cmd "$APP_ROOT" rev-parse "$DOKKU_DEPLOY_BRANCH" &>/dev/null; then
     dokku_log_fail "The fetch subcommand can only be executed for existing applications"
   fi
 
-  DOKKU_DEPLOY_BRANCH="$(fn-git-deploy-branch "$APP")"
+  DOKKU_DEPLOY_BRANCH="$(fn-git-computed-deploy-branch "$APP")"
   if ! fn-git-cmd "$APP_ROOT" check-ref-format --branch "$DOKKU_DEPLOY_BRANCH" &>/dev/null; then
     dokku_log_warn "Invalid branch name '$DOKKU_DEPLOY_BRANCH' specified via deploy-branch setting."
     dokku_log_warn "For more details, please see the man page for 'git-check-ref-format.'"
@@ -580,7 +580,7 @@ fn-git-has-code() {
   declare APP="$1" DOKKU_DEPLOY_BRANCH="$2"
 
   if [[ -z "$DOKKU_DEPLOY_BRANCH" ]]; then
-    DOKKU_DEPLOY_BRANCH="$(fn-git-deploy-branch "$APP")"
+    DOKKU_DEPLOY_BRANCH="$(fn-git-computed-deploy-branch "$APP")"
   fi
 
   local HEAD_FILE="$DOKKU_ROOT/$APP/refs/heads/$DOKKU_DEPLOY_BRANCH"
@@ -594,7 +594,7 @@ fn-git-has-code() {
 fn-git-last-updated-at() {
   declare desc="retrieve the deploy branch for a given application"
   declare APP="$1"
-  local DOKKU_DEPLOY_BRANCH="$(fn-git-deploy-branch "$APP")"
+  local DOKKU_DEPLOY_BRANCH="$(fn-git-computed-deploy-branch "$APP")"
   local HEAD_FILE="$DOKKU_ROOT/$APP/refs/heads/$DOKKU_DEPLOY_BRANCH"
 
   if [[ -f "$HEAD_FILE" ]]; then
@@ -602,7 +602,7 @@ fn-git-last-updated-at() {
   fi
 }
 
-fn-git-deploy-branch() {
+fn-git-computed-deploy-branch() {
   declare desc="retrieve the deploy branch for a given application"
   local APP="$1"
   local DEFAULT_BRANCH="${2-master}"
@@ -618,7 +618,7 @@ fn-git-deploy-branch() {
   fi
 }
 
-fn-git-keep-git-dir() {
+fn-git-computed-keep-git-dir() {
   declare desc="retrieve the keep-git-dir value for a given application"
   local APP="$1"
   local DEFAULT_KEEP_GIT_DIR="${2-false}"
@@ -636,7 +636,7 @@ fn-git-keep-git-dir() {
 
 fn-git-setup-build-dir() {
   declare APP="$1" GIT_WORKDIR="$2" REV="$3"
-  local DOKKU_KEEP_GIT_DIR="$(fn-git-keep-git-dir "$APP")"
+  local DOKKU_KEEP_GIT_DIR="$(fn-git-computed-keep-git-dir "$APP")"
 
   if [[ "$DOKKU_KEEP_GIT_DIR" == "true" ]]; then
     fn-git-setup-build-dir-new "$APP" "$GIT_WORKDIR" "$REV"
@@ -648,7 +648,7 @@ fn-git-setup-build-dir() {
 fn-git-setup-build-dir-new() {
   declare APP="$1" GIT_WORKDIR="$2" REV="$3"
   local APP_ROOT="$DOKKU_ROOT/$APP"
-  local DOKKU_DEPLOY_BRANCH="$(fn-git-deploy-branch "$APP")"
+  local DOKKU_DEPLOY_BRANCH="$(fn-git-computed-deploy-branch "$APP")"
 
   # unset the git quarantine path to allow us to use 2.13.0+
   # See this issue for more information: https://github.com/dokku/dokku/issues/2796
@@ -683,7 +683,7 @@ fn-git-setup-build-dir-worktree() {
 
 fn-git-setup-build-dir-submodules() {
   declare APP="$1" GIT_WORKDIR="$2"
-  local DOKKU_KEEP_GIT_DIR="$(fn-git-keep-git-dir "$APP")"
+  local DOKKU_KEEP_GIT_DIR="$(fn-git-computed-keep-git-dir "$APP")"
 
   # unset the git quarantine path to allow us to use 2.13.0+
   # See this issue for more information: https://github.com/dokku/dokku/issues/2796
diff --git a/plugins/logs/report.go b/plugins/logs/report.go
index 4de190711..a786ece6d 100644
--- a/plugins/logs/report.go
+++ b/plugins/logs/report.go
@@ -22,23 +22,29 @@ func ReportSingleApp(appName string, format string, infoFlag string) error {
 		flags = map[string]common.ReportFunc{
 			"--logs-computed-app-label-alias": reportComputedAppLabelAlias,
 			"--logs-computed-max-size":        reportComputedMaxSize,
+			"--logs-computed-vector-image":    reportComputedVectorImage,
+			"--logs-computed-vector-networks": reportComputedVectorNetworks,
+			"--logs-computed-vector-sink":     reportComputedVectorSink,
 			"--logs-global-app-label-alias":   reportGlobalAppLabelAlias,
 			"--logs-global-max-size":          reportGlobalMaxSize,
+			"--logs-global-vector-image":      reportGlobalVectorImage,
+			"--logs-global-vector-networks":   reportGlobalVectorNetworks,
 			"--logs-global-vector-sink":       reportGlobalVectorSink,
-			"--logs-vector-global-image":      reportVectorGlobalImage,
-			"--logs-vector-global-networks":   reportVectorGlobalNetworks,
 		}
 	} else {
 		flags = map[string]common.ReportFunc{
+			"--logs-app-label-alias":          reportAppLabelAlias,
 			"--logs-computed-app-label-alias": reportComputedAppLabelAlias,
 			"--logs-computed-max-size":        reportComputedMaxSize,
+			"--logs-computed-vector-image":    reportComputedVectorImage,
+			"--logs-computed-vector-networks": reportComputedVectorNetworks,
+			"--logs-computed-vector-sink":     reportComputedVectorSink,
 			"--logs-global-app-label-alias":   reportGlobalAppLabelAlias,
 			"--logs-global-max-size":          reportGlobalMaxSize,
+			"--logs-global-vector-image":      reportGlobalVectorImage,
+			"--logs-global-vector-networks":   reportGlobalVectorNetworks,
 			"--logs-global-vector-sink":       reportGlobalVectorSink,
-			"--logs-app-label-alias":          reportAppLabelAlias,
 			"--logs-max-size":                 reportMaxSize,
-			"--logs-vector-global-image":      reportVectorGlobalImage,
-			"--logs-vector-global-networks":   reportVectorGlobalNetworks,
 			"--logs-vector-sink":              reportVectorSink,
 		}
 	}
@@ -90,14 +96,30 @@ func reportGlobalMaxSize(appName string) string {
 	return common.PropertyGet("logs", "--global", "max-size")
 }
 
-func reportVectorGlobalImage(appName string) string {
+func reportGlobalVectorImage(appName string) string {
+	return common.PropertyGet("logs", "--global", "vector-image")
+}
+
+func reportComputedVectorImage(appName string) string {
 	return getComputedVectorImage()
 }
 
-func reportVectorGlobalNetworks(appName string) string {
+func reportGlobalVectorNetworks(appName string) string {
 	return common.PropertyGet("logs", "--global", "vector-networks")
 }
 
+func reportComputedVectorNetworks(appName string) string {
+	return reportGlobalVectorNetworks(appName)
+}
+
+func reportComputedVectorSink(appName string) string {
+	value := reportVectorSink(appName)
+	if value == "" {
+		value = reportGlobalVectorSink(appName)
+	}
+	return value
+}
+
 func reportGlobalVectorSink(appName string) string {
 	value := common.PropertyGet("logs", "--global", "vector-sink")
 	if value == "" {
diff --git a/plugins/network/report.go b/plugins/network/report.go
index 00a05196b..38deeed1d 100644
--- a/plugins/network/report.go
+++ b/plugins/network/report.go
@@ -17,7 +17,11 @@ func ReportSingleApp(appName string, format string, infoFlag string) error {
 	var flags map[string]common.ReportFunc
 	if appName == "--global" {
 		flags = map[string]common.ReportFunc{
+			"--network-computed-attach-post-create":  reportComputedAttachPostCreate,
+			"--network-computed-attach-post-deploy":  reportComputedAttachPostDeploy,
 			"--network-computed-bind-all-interfaces": reportComputedBindAllInterfaces,
+			"--network-computed-initial-network":     reportComputedInitialNetwork,
+			"--network-computed-tld":                 reportComputedTld,
 			"--network-global-attach-post-create":    reportGlobalAttachPostCreate,
 			"--network-global-attach-post-deploy":    reportGlobalAttachPostDeploy,
 			"--network-global-bind-all-interfaces":   reportGlobalBindAllInterfaces,
diff --git a/tests/unit/buildpacks.bats b/tests/unit/buildpacks.bats
index 02249e531..6c4ff9ec2 100644
--- a/tests/unit/buildpacks.bats
+++ b/tests/unit/buildpacks.bats
@@ -195,37 +195,37 @@ teardown() {
   run /bin/bash -c "dokku buildpacks:set-property --global stack"
   assert_success
 
-  run /bin/bash -c "dokku --quiet buildpacks:report $TEST_APP --format json | jq -r '.\"buildpacks-stack\"'"
+  run /bin/bash -c "dokku buildpacks:report $TEST_APP --format json | jq -r '.\"buildpacks-stack\"'"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet buildpacks:report $TEST_APP --format json | jq -r '.\"buildpacks-global-stack\"'"
+  run /bin/bash -c "dokku buildpacks:report $TEST_APP --format json | jq -r '.\"buildpacks-global-stack\"'"
   assert_success
   assert_output ""
 
   run /bin/bash -c "dokku buildpacks:set-property --global stack gliderlabs/herokuish:global"
   assert_success
 
-  run /bin/bash -c "dokku --quiet buildpacks:report $TEST_APP --format json | jq -r '.\"buildpacks-global-stack\"'"
+  run /bin/bash -c "dokku buildpacks:report $TEST_APP --format json | jq -r '.\"buildpacks-global-stack\"'"
   assert_success
   assert_output "gliderlabs/herokuish:global"
 
-  run /bin/bash -c "dokku --quiet buildpacks:report $TEST_APP --format json | jq -r '.\"buildpacks-computed-stack\"'"
+  run /bin/bash -c "dokku buildpacks:report $TEST_APP --format json | jq -r '.\"buildpacks-computed-stack\"'"
   assert_success
   assert_output "gliderlabs/herokuish:global"
 
   run /bin/bash -c "dokku buildpacks:set-property $TEST_APP stack gliderlabs/herokuish:app"
   assert_success
 
-  run /bin/bash -c "dokku --quiet buildpacks:report $TEST_APP --format json | jq -r '.\"buildpacks-stack\"'"
+  run /bin/bash -c "dokku buildpacks:report $TEST_APP --format json | jq -r '.\"buildpacks-stack\"'"
   assert_success
   assert_output "gliderlabs/herokuish:app"
 
-  run /bin/bash -c "dokku --quiet buildpacks:report $TEST_APP --format json | jq -r '.\"buildpacks-global-stack\"'"
+  run /bin/bash -c "dokku buildpacks:report $TEST_APP --format json | jq -r '.\"buildpacks-global-stack\"'"
   assert_success
   assert_output "gliderlabs/herokuish:global"
 
-  run /bin/bash -c "dokku --quiet buildpacks:report $TEST_APP --format json | jq -r '.\"buildpacks-computed-stack\"'"
+  run /bin/bash -c "dokku buildpacks:report $TEST_APP --format json | jq -r '.\"buildpacks-computed-stack\"'"
   assert_success
   assert_output "gliderlabs/herokuish:app"
 
diff --git a/tests/unit/caddy.bats b/tests/unit/caddy.bats
index 2e6b68ecb..dd1e48658 100644
--- a/tests/unit/caddy.bats
+++ b/tests/unit/caddy.bats
@@ -67,25 +67,25 @@ teardown() {
 }
 
 @test "(caddy:report) --global raw and computed keys in --format json" {
-  run /bin/bash -c "dokku --quiet caddy:report --global --format json | jq -r '.\"global-image\"'"
+  run /bin/bash -c "dokku caddy:report --global --format json | jq -r '.\"global-image\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet caddy:report --global --format json | jq -r '.\"computed-image\"'"
+  run /bin/bash -c "dokku caddy:report --global --format json | jq -r '.\"computed-image\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
   assert_output_exists
 
-  run /bin/bash -c "dokku --quiet caddy:report --global --format json | jq -r '.\"global-polling-interval\"'"
+  run /bin/bash -c "dokku caddy:report --global --format json | jq -r '.\"global-polling-interval\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet caddy:report --global --format json | jq -r '.\"computed-polling-interval\"'"
+  run /bin/bash -c "dokku caddy:report --global --format json | jq -r '.\"computed-polling-interval\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
@@ -350,12 +350,12 @@ teardown() {
   assert_success
   assert_output "$TEST_APP.${DOKKU_DOMAIN}"
 
-  run /bin/bash -c "dokku --quiet ports:report $TEST_APP --ports-map"
+  run /bin/bash -c "dokku ports:report $TEST_APP --ports-map"
   echo "output: $output"
   echo "status: $status"
   assert_output_not_exists
 
-  run /bin/bash -c "dokku --quiet ports:report $TEST_APP --ports-map-detected"
+  run /bin/bash -c "dokku ports:report $TEST_APP --ports-map-detected"
   echo "output: $output"
   echo "status: $status"
   assert_output "http:80:5000 https:443:5000"
diff --git a/tests/unit/checks.bats b/tests/unit/checks.bats
index bf17cebe6..365702002 100644
--- a/tests/unit/checks.bats
+++ b/tests/unit/checks.bats
@@ -46,18 +46,18 @@ teardown() {
   echo "status: $status"
   assert_success
 
-  run /bin/bash -c "dokku --quiet checks:report --global --format json | jq -e ."
+  run /bin/bash -c "dokku checks:report --global --format json | jq -e ."
   echo "output: $output"
   echo "status: $status"
   assert_success
 
-  run /bin/bash -c "dokku --quiet checks:report --global --format json | jq -r '.\"global-wait-to-retire\"'"
+  run /bin/bash -c "dokku checks:report --global --format json | jq -r '.\"global-wait-to-retire\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet checks:report --global --format json | jq -r '.\"computed-wait-to-retire\"'"
+  run /bin/bash -c "dokku checks:report --global --format json | jq -r '.\"computed-wait-to-retire\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
@@ -68,13 +68,13 @@ teardown() {
   echo "status: $status"
   assert_success
 
-  run /bin/bash -c "dokku --quiet checks:report --global --format json | jq -r '.\"global-wait-to-retire\"'"
+  run /bin/bash -c "dokku checks:report --global --format json | jq -r '.\"global-wait-to-retire\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
   assert_output "90"
 
-  run /bin/bash -c "dokku --quiet checks:report --global --format json | jq -r '.\"computed-wait-to-retire\"'"
+  run /bin/bash -c "dokku checks:report --global --format json | jq -r '.\"computed-wait-to-retire\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
diff --git a/tests/unit/cron.bats b/tests/unit/cron.bats
index 7fb47a526..c81f69f5b 100644
--- a/tests/unit/cron.bats
+++ b/tests/unit/cron.bats
@@ -190,37 +190,37 @@ teardown() {
   run /bin/bash -c "dokku cron:set --global maintenance"
   assert_success
 
-  run /bin/bash -c "dokku --quiet cron:report $TEST_APP --format json | jq -r '.\"cron-maintenance\"'"
+  run /bin/bash -c "dokku cron:report $TEST_APP --format json | jq -r '.\"cron-maintenance\"'"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet cron:report $TEST_APP --format json | jq -r '.\"cron-global-maintenance\"'"
+  run /bin/bash -c "dokku cron:report $TEST_APP --format json | jq -r '.\"cron-global-maintenance\"'"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet cron:report $TEST_APP --format json | jq -r '.\"cron-computed-maintenance\"'"
+  run /bin/bash -c "dokku cron:report $TEST_APP --format json | jq -r '.\"cron-computed-maintenance\"'"
   assert_success
   assert_output "false"
 
   run /bin/bash -c "dokku cron:set --global maintenance true"
   assert_success
 
-  run /bin/bash -c "dokku --quiet cron:report $TEST_APP --format json | jq -r '.\"cron-global-maintenance\"'"
+  run /bin/bash -c "dokku cron:report $TEST_APP --format json | jq -r '.\"cron-global-maintenance\"'"
   assert_success
   assert_output "true"
 
-  run /bin/bash -c "dokku --quiet cron:report $TEST_APP --format json | jq -r '.\"cron-computed-maintenance\"'"
+  run /bin/bash -c "dokku cron:report $TEST_APP --format json | jq -r '.\"cron-computed-maintenance\"'"
   assert_success
   assert_output "true"
 
   run /bin/bash -c "dokku cron:set $TEST_APP maintenance true"
   assert_success
 
-  run /bin/bash -c "dokku --quiet cron:report $TEST_APP --format json | jq -r '.\"cron-maintenance\"'"
+  run /bin/bash -c "dokku cron:report $TEST_APP --format json | jq -r '.\"cron-maintenance\"'"
   assert_success
   assert_output "true"
 
-  run /bin/bash -c "dokku --quiet cron:report $TEST_APP --format json | jq -r '.\"cron-global-maintenance\"'"
+  run /bin/bash -c "dokku cron:report $TEST_APP --format json | jq -r '.\"cron-global-maintenance\"'"
   assert_success
   assert_output "true"
 
@@ -228,7 +228,7 @@ teardown() {
   # "true" (cron's logic at plugins/cron/report.go::reportComputedMaintenance
   # is OR-not-override: any "true" wins). This is intentional for maintenance
   # mode - a per-app "false" does NOT override a global "true".
-  run /bin/bash -c "dokku --quiet cron:report $TEST_APP --format json | jq -r '.\"cron-computed-maintenance\"'"
+  run /bin/bash -c "dokku cron:report $TEST_APP --format json | jq -r '.\"cron-computed-maintenance\"'"
   assert_success
   assert_output "true"
 
diff --git a/tests/unit/git_1.bats b/tests/unit/git_1.bats
index a1c7975c0..46410f0c9 100644
--- a/tests/unit/git_1.bats
+++ b/tests/unit/git_1.bats
@@ -182,25 +182,25 @@ teardown() {
 }
 
 @test "(git:report) --global raw and computed keys" {
-  run /bin/bash -c "dokku --quiet git:report --global --format json | jq -r '.\"global-deploy-branch\"'"
+  run /bin/bash -c "dokku git:report --global --format json | jq -r '.\"global-deploy-branch\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet git:report --global --format json | jq -r '.\"computed-deploy-branch\"'"
+  run /bin/bash -c "dokku git:report --global --format json | jq -r '.\"computed-deploy-branch\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
   assert_output "master"
 
-  run /bin/bash -c "dokku --quiet git:report --global --format json | jq -r '.\"global-archive-max-files\"'"
+  run /bin/bash -c "dokku git:report --global --format json | jq -r '.\"global-archive-max-files\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet git:report --global --format json | jq -r '.\"computed-archive-max-files\"'"
+  run /bin/bash -c "dokku git:report --global --format json | jq -r '.\"computed-archive-max-files\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
@@ -211,13 +211,13 @@ teardown() {
   echo "status: $status"
   assert_success
 
-  run /bin/bash -c "dokku --quiet git:report --global --format json | jq -r '.\"global-deploy-branch\"'"
+  run /bin/bash -c "dokku git:report --global --format json | jq -r '.\"global-deploy-branch\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
   assert_output "main"
 
-  run /bin/bash -c "dokku --quiet git:report --global --format json | jq -r '.\"computed-deploy-branch\"'"
+  run /bin/bash -c "dokku git:report --global --format json | jq -r '.\"computed-deploy-branch\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
@@ -228,7 +228,7 @@ teardown() {
   echo "status: $status"
   assert_success
 
-  run /bin/bash -c "dokku --quiet git:report --global --format json | jq -r '.\"global-deploy-branch\"'"
+  run /bin/bash -c "dokku git:report --global --format json | jq -r '.\"global-deploy-branch\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
diff --git a/tests/unit/haproxy.bats b/tests/unit/haproxy.bats
index ed3a3d77a..6edc97db8 100644
--- a/tests/unit/haproxy.bats
+++ b/tests/unit/haproxy.bats
@@ -97,25 +97,25 @@ teardown() {
   run /bin/bash -c "dokku haproxy:set --global refresh-conf"
   assert_success
 
-  run /bin/bash -c "dokku --quiet haproxy:report --global --format json | jq -r '.\"global-image\"'"
+  run /bin/bash -c "dokku haproxy:report --global --format json | jq -r '.\"global-image\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet haproxy:report --global --format json | jq -r '.\"computed-image\"'"
+  run /bin/bash -c "dokku haproxy:report --global --format json | jq -r '.\"computed-image\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
   assert_output_exists
 
-  run /bin/bash -c "dokku --quiet haproxy:report --global --format json | jq -r '.\"global-refresh-conf\"'"
+  run /bin/bash -c "dokku haproxy:report --global --format json | jq -r '.\"global-refresh-conf\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet haproxy:report --global --format json | jq -r '.\"computed-refresh-conf\"'"
+  run /bin/bash -c "dokku haproxy:report --global --format json | jq -r '.\"computed-refresh-conf\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
@@ -246,12 +246,12 @@ teardown() {
   assert_success
   assert_output "true"
 
-  run /bin/bash -c "dokku --quiet ports:report $TEST_APP --ports-map"
+  run /bin/bash -c "dokku ports:report $TEST_APP --ports-map"
   echo "output: $output"
   echo "status: $status"
   assert_output_not_exists
 
-  run /bin/bash -c "dokku --quiet ports:report $TEST_APP --ports-map-detected"
+  run /bin/bash -c "dokku ports:report $TEST_APP --ports-map-detected"
   echo "output: $output"
   echo "status: $status"
   assert_output "http:80:5000 https:443:5000"
diff --git a/tests/unit/logs.bats b/tests/unit/logs.bats
index 027b32b94..8913b62b2 100644
--- a/tests/unit/logs.bats
+++ b/tests/unit/logs.bats
@@ -492,25 +492,25 @@ teardown() {
   run /bin/bash -c "dokku logs:set --global vector-sink"
   assert_success
 
-  run /bin/bash -c "dokku --quiet logs:report $TEST_APP --format json | jq -r '.\"logs-vector-sink\"'"
+  run /bin/bash -c "dokku logs:report $TEST_APP --format json | jq -r '.\"logs-vector-sink\"'"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet logs:report $TEST_APP --format json | jq -r '.\"logs-global-vector-sink\"'"
+  run /bin/bash -c "dokku logs:report $TEST_APP --format json | jq -r '.\"logs-global-vector-sink\"'"
   assert_success
   assert_output ""
 
   run /bin/bash -c "dokku logs:set --global vector-sink console://?encoding[codec]=json"
   assert_success
 
-  run /bin/bash -c "dokku --quiet logs:report $TEST_APP --format json | jq -r '.\"logs-global-vector-sink\"'"
+  run /bin/bash -c "dokku logs:report $TEST_APP --format json | jq -r '.\"logs-global-vector-sink\"'"
   assert_success
   assert_output "console://?encoding[codec]=json"
 
   run /bin/bash -c "dokku logs:set $TEST_APP vector-sink datadog_logs://?api_key=abc"
   assert_success
 
-  run /bin/bash -c "dokku --quiet logs:report $TEST_APP --format json | jq -r '.\"logs-vector-sink\"'"
+  run /bin/bash -c "dokku logs:report $TEST_APP --format json | jq -r '.\"logs-vector-sink\"'"
   assert_success
   assert_output "datadog_logs://?api_key=abc"
 
@@ -528,21 +528,21 @@ teardown() {
   run /bin/bash -c "dokku logs:set --global vector-image"
   assert_success
 
-  run /bin/bash -c "dokku --quiet logs:report --global --format json | jq -r '.\"logs-vector-global-image\"'"
+  run /bin/bash -c "dokku logs:report --global --format json | jq -r '.\"logs-vector-global-image\"'"
   assert_success
   assert_output_exists
 
   run /bin/bash -c "dokku logs:set --global vector-image timberio/vector:custom"
   assert_success
 
-  run /bin/bash -c "dokku --quiet logs:report --global --format json | jq -r '.\"logs-vector-global-image\"'"
+  run /bin/bash -c "dokku logs:report --global --format json | jq -r '.\"logs-vector-global-image\"'"
   assert_success
   assert_output "timberio/vector:custom"
 
   run /bin/bash -c "dokku logs:set --global vector-image"
   assert_success
 
-  run /bin/bash -c "dokku --quiet logs:report --global --format json | jq -r '.\"logs-vector-global-networks\"'"
+  run /bin/bash -c "dokku logs:report --global --format json | jq -r '.\"logs-vector-global-networks\"'"
   assert_success
   assert_output ""
 }
diff --git a/tests/unit/network.bats b/tests/unit/network.bats
index 91f72b732..79f7e9ed3 100644
--- a/tests/unit/network.bats
+++ b/tests/unit/network.bats
@@ -72,7 +72,7 @@ teardown() {
   echo "status: $status"
   assert_success
 
-  run /bin/bash -c "dokku --quiet network:report --global --format json | jq -r '.\"network-global-tld\"'"
+  run /bin/bash -c "dokku network:report --global --format json | jq -r '.\"network-global-tld\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
@@ -83,19 +83,19 @@ teardown() {
   echo "status: $status"
   assert_success
 
-  run /bin/bash -c "dokku --quiet network:report --global --format json | jq -r '.\"network-global-tld\"'"
+  run /bin/bash -c "dokku network:report --global --format json | jq -r '.\"network-global-tld\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
   assert_output "example.test"
 
-  run /bin/bash -c "dokku --quiet network:report $TEST_APP --format json | jq -r '.\"network-global-tld\"'"
+  run /bin/bash -c "dokku network:report $TEST_APP --format json | jq -r '.\"network-global-tld\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
   assert_output "example.test"
 
-  run /bin/bash -c "dokku --quiet network:report $TEST_APP --format json | jq -r '.\"network-computed-tld\"'"
+  run /bin/bash -c "dokku network:report $TEST_APP --format json | jq -r '.\"network-computed-tld\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
@@ -112,26 +112,26 @@ teardown() {
   run /bin/bash -c "dokku network:set --global attach-post-create"
   assert_success
 
-  run /bin/bash -c "dokku --quiet network:report $TEST_APP --format json | jq -r '.\"network-attach-post-create\"'"
+  run /bin/bash -c "dokku network:report $TEST_APP --format json | jq -r '.\"network-attach-post-create\"'"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet network:report $TEST_APP --format json | jq -r '.\"network-global-attach-post-create\"'"
+  run /bin/bash -c "dokku network:report $TEST_APP --format json | jq -r '.\"network-global-attach-post-create\"'"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet network:report $TEST_APP --format json | jq -r '.\"network-computed-attach-post-create\"'"
+  run /bin/bash -c "dokku network:report $TEST_APP --format json | jq -r '.\"network-computed-attach-post-create\"'"
   assert_success
   assert_output ""
 
   run /bin/bash -c "dokku network:set --global attach-post-create create-network-x"
   assert_success
 
-  run /bin/bash -c "dokku --quiet network:report $TEST_APP --format json | jq -r '.\"network-global-attach-post-create\"'"
+  run /bin/bash -c "dokku network:report $TEST_APP --format json | jq -r '.\"network-global-attach-post-create\"'"
   assert_success
   assert_output "create-network-x"
 
-  run /bin/bash -c "dokku --quiet network:report $TEST_APP --format json | jq -r '.\"network-computed-attach-post-create\"'"
+  run /bin/bash -c "dokku network:report $TEST_APP --format json | jq -r '.\"network-computed-attach-post-create\"'"
   assert_success
   assert_output "create-network-x"
 
@@ -146,22 +146,22 @@ teardown() {
   run /bin/bash -c "dokku network:set --global attach-post-deploy"
   assert_success
 
-  run /bin/bash -c "dokku --quiet network:report $TEST_APP --format json | jq -r '.\"network-attach-post-deploy\"'"
+  run /bin/bash -c "dokku network:report $TEST_APP --format json | jq -r '.\"network-attach-post-deploy\"'"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet network:report $TEST_APP --format json | jq -r '.\"network-global-attach-post-deploy\"'"
+  run /bin/bash -c "dokku network:report $TEST_APP --format json | jq -r '.\"network-global-attach-post-deploy\"'"
   assert_success
   assert_output ""
 
   run /bin/bash -c "dokku network:set --global attach-post-deploy deploy-network-x"
   assert_success
 
-  run /bin/bash -c "dokku --quiet network:report $TEST_APP --format json | jq -r '.\"network-global-attach-post-deploy\"'"
+  run /bin/bash -c "dokku network:report $TEST_APP --format json | jq -r '.\"network-global-attach-post-deploy\"'"
   assert_success
   assert_output "deploy-network-x"
 
-  run /bin/bash -c "dokku --quiet network:report $TEST_APP --format json | jq -r '.\"network-computed-attach-post-deploy\"'"
+  run /bin/bash -c "dokku network:report $TEST_APP --format json | jq -r '.\"network-computed-attach-post-deploy\"'"
   assert_success
   assert_output "deploy-network-x"
 
@@ -176,22 +176,22 @@ teardown() {
   run /bin/bash -c "dokku network:set --global initial-network"
   assert_success
 
-  run /bin/bash -c "dokku --quiet network:report $TEST_APP --format json | jq -r '.\"network-initial-network\"'"
+  run /bin/bash -c "dokku network:report $TEST_APP --format json | jq -r '.\"network-initial-network\"'"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet network:report $TEST_APP --format json | jq -r '.\"network-global-initial-network\"'"
+  run /bin/bash -c "dokku network:report $TEST_APP --format json | jq -r '.\"network-global-initial-network\"'"
   assert_success
   assert_output ""
 
   run /bin/bash -c "dokku network:set --global initial-network initial-network-x"
   assert_success
 
-  run /bin/bash -c "dokku --quiet network:report $TEST_APP --format json | jq -r '.\"network-global-initial-network\"'"
+  run /bin/bash -c "dokku network:report $TEST_APP --format json | jq -r '.\"network-global-initial-network\"'"
   assert_success
   assert_output "initial-network-x"
 
-  run /bin/bash -c "dokku --quiet network:report $TEST_APP --format json | jq -r '.\"network-computed-initial-network\"'"
+  run /bin/bash -c "dokku network:report $TEST_APP --format json | jq -r '.\"network-computed-initial-network\"'"
   assert_success
   assert_output "initial-network-x"
 
diff --git a/tests/unit/nginx-vhosts_properties.bats b/tests/unit/nginx-vhosts_properties.bats
index 0830a887f..accc328d6 100644
--- a/tests/unit/nginx-vhosts_properties.bats
+++ b/tests/unit/nginx-vhosts_properties.bats
@@ -30,26 +30,26 @@ assert_nginx_property_set_get() {
   run /bin/bash -c "dokku nginx:set --global $prop '$global_value'"
   assert_success
 
-  run /bin/bash -c "dokku --quiet nginx:report $TEST_APP --format json | jq -r '.\"global-$prop\"'"
+  run /bin/bash -c "dokku nginx:report $TEST_APP --format json | jq -r '.\"global-$prop\"'"
   assert_success
   assert_output "$global_value"
 
-  run /bin/bash -c "dokku --quiet nginx:report $TEST_APP --format json | jq -r '.\"computed-$prop\"'"
+  run /bin/bash -c "dokku nginx:report $TEST_APP --format json | jq -r '.\"computed-$prop\"'"
   assert_success
   assert_output "$global_value"
 
   run /bin/bash -c "dokku nginx:set $TEST_APP $prop '$app_value'"
   assert_success
 
-  run /bin/bash -c "dokku --quiet nginx:report $TEST_APP --format json | jq -r '.\"$prop\"'"
+  run /bin/bash -c "dokku nginx:report $TEST_APP --format json | jq -r '.\"$prop\"'"
   assert_success
   assert_output "$app_value"
 
-  run /bin/bash -c "dokku --quiet nginx:report $TEST_APP --format json | jq -r '.\"global-$prop\"'"
+  run /bin/bash -c "dokku nginx:report $TEST_APP --format json | jq -r '.\"global-$prop\"'"
   assert_success
   assert_output "$global_value"
 
-  run /bin/bash -c "dokku --quiet nginx:report $TEST_APP --format json | jq -r '.\"computed-$prop\"'"
+  run /bin/bash -c "dokku nginx:report $TEST_APP --format json | jq -r '.\"computed-$prop\"'"
   assert_success
   assert_output "$app_value"
 
diff --git a/tests/unit/proxy.bats b/tests/unit/proxy.bats
index 1d2ec2ea5..77d9cd625 100644
--- a/tests/unit/proxy.bats
+++ b/tests/unit/proxy.bats
@@ -29,13 +29,13 @@ teardown() {
 }
 
 @test "(proxy:report) --global raw vs computed type" {
-  run /bin/bash -c "dokku --quiet proxy:report --global --format json | jq -r '.\"proxy-global-type\"'"
+  run /bin/bash -c "dokku proxy:report --global --format json | jq -r '.\"proxy-global-type\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet proxy:report --global --format json | jq -r '.\"proxy-computed-type\"'"
+  run /bin/bash -c "dokku proxy:report --global --format json | jq -r '.\"proxy-computed-type\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
@@ -46,13 +46,13 @@ teardown() {
   echo "status: $status"
   assert_success
 
-  run /bin/bash -c "dokku --quiet proxy:report --global --format json | jq -r '.\"proxy-global-type\"'"
+  run /bin/bash -c "dokku proxy:report --global --format json | jq -r '.\"proxy-global-type\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
   assert_output "caddy"
 
-  run /bin/bash -c "dokku --quiet proxy:report --global --format json | jq -r '.\"proxy-computed-type\"'"
+  run /bin/bash -c "dokku proxy:report --global --format json | jq -r '.\"proxy-computed-type\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
@@ -63,13 +63,13 @@ teardown() {
   echo "status: $status"
   assert_success
 
-  run /bin/bash -c "dokku --quiet proxy:report --global --format json | jq -r '.\"proxy-global-type\"'"
+  run /bin/bash -c "dokku proxy:report --global --format json | jq -r '.\"proxy-global-type\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet proxy:report --global --format json | jq -r '.\"proxy-computed-type\"'"
+  run /bin/bash -c "dokku proxy:report --global --format json | jq -r '.\"proxy-computed-type\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
@@ -80,41 +80,41 @@ teardown() {
   run /bin/bash -c "dokku proxy:set --global type"
   assert_success
 
-  run /bin/bash -c "dokku --quiet proxy:report $TEST_APP --format json | jq -r '.\"proxy-type\"'"
+  run /bin/bash -c "dokku proxy:report $TEST_APP --format json | jq -r '.\"proxy-type\"'"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet proxy:report $TEST_APP --format json | jq -r '.\"proxy-global-type\"'"
+  run /bin/bash -c "dokku proxy:report $TEST_APP --format json | jq -r '.\"proxy-global-type\"'"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet proxy:report $TEST_APP --format json | jq -r '.\"proxy-computed-type\"'"
+  run /bin/bash -c "dokku proxy:report $TEST_APP --format json | jq -r '.\"proxy-computed-type\"'"
   assert_success
   assert_output "nginx"
 
   run /bin/bash -c "dokku proxy:set --global type caddy"
   assert_success
 
-  run /bin/bash -c "dokku --quiet proxy:report $TEST_APP --format json | jq -r '.\"proxy-global-type\"'"
+  run /bin/bash -c "dokku proxy:report $TEST_APP --format json | jq -r '.\"proxy-global-type\"'"
   assert_success
   assert_output "caddy"
 
-  run /bin/bash -c "dokku --quiet proxy:report $TEST_APP --format json | jq -r '.\"proxy-computed-type\"'"
+  run /bin/bash -c "dokku proxy:report $TEST_APP --format json | jq -r '.\"proxy-computed-type\"'"
   assert_success
   assert_output "caddy"
 
   run /bin/bash -c "dokku proxy:set $TEST_APP type traefik"
   assert_success
 
-  run /bin/bash -c "dokku --quiet proxy:report $TEST_APP --format json | jq -r '.\"proxy-type\"'"
+  run /bin/bash -c "dokku proxy:report $TEST_APP --format json | jq -r '.\"proxy-type\"'"
   assert_success
   assert_output "traefik"
 
-  run /bin/bash -c "dokku --quiet proxy:report $TEST_APP --format json | jq -r '.\"proxy-global-type\"'"
+  run /bin/bash -c "dokku proxy:report $TEST_APP --format json | jq -r '.\"proxy-global-type\"'"
   assert_success
   assert_output "caddy"
 
-  run /bin/bash -c "dokku --quiet proxy:report $TEST_APP --format json | jq -r '.\"proxy-computed-type\"'"
+  run /bin/bash -c "dokku proxy:report $TEST_APP --format json | jq -r '.\"proxy-computed-type\"'"
   assert_success
   assert_output "traefik"
 
diff --git a/tests/unit/ps-general-1.bats b/tests/unit/ps-general-1.bats
index 657c65261..24a38c9c4 100644
--- a/tests/unit/ps-general-1.bats
+++ b/tests/unit/ps-general-1.bats
@@ -172,41 +172,41 @@ web
   run /bin/bash -c "dokku ps:set --global stop-timeout-seconds"
   assert_success
 
-  run /bin/bash -c "dokku --quiet ps:report $TEST_APP --format json | jq -r '.\"stop-timeout-seconds\"'"
+  run /bin/bash -c "dokku ps:report $TEST_APP --format json | jq -r '.\"stop-timeout-seconds\"'"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet ps:report $TEST_APP --format json | jq -r '.\"global-stop-timeout-seconds\"'"
+  run /bin/bash -c "dokku ps:report $TEST_APP --format json | jq -r '.\"global-stop-timeout-seconds\"'"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet ps:report $TEST_APP --format json | jq -r '.\"computed-stop-timeout-seconds\"'"
+  run /bin/bash -c "dokku ps:report $TEST_APP --format json | jq -r '.\"computed-stop-timeout-seconds\"'"
   assert_success
   assert_output "30"
 
   run /bin/bash -c "dokku ps:set --global stop-timeout-seconds 90"
   assert_success
 
-  run /bin/bash -c "dokku --quiet ps:report $TEST_APP --format json | jq -r '.\"global-stop-timeout-seconds\"'"
+  run /bin/bash -c "dokku ps:report $TEST_APP --format json | jq -r '.\"global-stop-timeout-seconds\"'"
   assert_success
   assert_output "90"
 
-  run /bin/bash -c "dokku --quiet ps:report $TEST_APP --format json | jq -r '.\"computed-stop-timeout-seconds\"'"
+  run /bin/bash -c "dokku ps:report $TEST_APP --format json | jq -r '.\"computed-stop-timeout-seconds\"'"
   assert_success
   assert_output "90"
 
   run /bin/bash -c "dokku ps:set $TEST_APP stop-timeout-seconds 45"
   assert_success
 
-  run /bin/bash -c "dokku --quiet ps:report $TEST_APP --format json | jq -r '.\"stop-timeout-seconds\"'"
+  run /bin/bash -c "dokku ps:report $TEST_APP --format json | jq -r '.\"stop-timeout-seconds\"'"
   assert_success
   assert_output "45"
 
-  run /bin/bash -c "dokku --quiet ps:report $TEST_APP --format json | jq -r '.\"global-stop-timeout-seconds\"'"
+  run /bin/bash -c "dokku ps:report $TEST_APP --format json | jq -r '.\"global-stop-timeout-seconds\"'"
   assert_success
   assert_output "90"
 
-  run /bin/bash -c "dokku --quiet ps:report $TEST_APP --format json | jq -r '.\"computed-stop-timeout-seconds\"'"
+  run /bin/bash -c "dokku ps:report $TEST_APP --format json | jq -r '.\"computed-stop-timeout-seconds\"'"
   assert_success
   assert_output "45"
 
@@ -218,7 +218,7 @@ web
 }
 
 @test "(ps:restart-policy) default policy" {
-  run /bin/bash -c "dokku --quiet ps:report $TEST_APP --ps-restart-policy"
+  run /bin/bash -c "dokku ps:report $TEST_APP --ps-restart-policy"
   echo "output: $output"
   echo "status: $status"
   assert_output "on-failure:10"
@@ -231,7 +231,7 @@ web
     echo "status: $status"
     assert_success
 
-    run /bin/bash -c "dokku --quiet ps:report $TEST_APP --ps-restart-policy"
+    run /bin/bash -c "dokku ps:report $TEST_APP --ps-restart-policy"
     echo "output: $output"
     echo "status: $status"
     assert_output "$policy"
@@ -245,7 +245,7 @@ web
   echo "status: $status"
   assert_success
 
-  run /bin/bash -c "dokku --quiet ps:report $TEST_APP --ps-restart-policy"
+  run /bin/bash -c "dokku ps:report $TEST_APP --ps-restart-policy"
   echo "output: $output"
   echo "status: $status"
   assert_output "$test_restart_policy"
diff --git a/tests/unit/registry.bats b/tests/unit/registry.bats
index da6963592..b027bf03c 100644
--- a/tests/unit/registry.bats
+++ b/tests/unit/registry.bats
@@ -137,40 +137,40 @@ teardown() {
   run /bin/bash -c "dokku registry:set --global image-repo-template"
   assert_success
 
-  run /bin/bash -c "dokku --quiet registry:report $TEST_APP --format json | jq -r '.\"registry-image-repo\"'"
+  run /bin/bash -c "dokku registry:report $TEST_APP --format json | jq -r '.\"registry-image-repo\"'"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet registry:report $TEST_APP --format json | jq -r '.\"registry-global-image-repo-template\"'"
+  run /bin/bash -c "dokku registry:report $TEST_APP --format json | jq -r '.\"registry-global-image-repo-template\"'"
   assert_success
   assert_output ""
 
   # When neither per-app image-repo nor a global image-repo-template are set,
   # reportComputedImageRepo falls back to common.GetAppImageRepo which returns
   # the default dokku/<app> image name.
-  run /bin/bash -c "dokku --quiet registry:report $TEST_APP --format json | jq -r '.\"registry-computed-image-repo\"'"
+  run /bin/bash -c "dokku registry:report $TEST_APP --format json | jq -r '.\"registry-computed-image-repo\"'"
   assert_success
   assert_output "dokku/$TEST_APP"
 
   run /bin/bash -c "dokku registry:set --global image-repo-template 'dokku/{{ APP }}'"
   assert_success
 
-  run /bin/bash -c "dokku --quiet registry:report $TEST_APP --format json | jq -r '.\"registry-global-image-repo-template\"'"
+  run /bin/bash -c "dokku registry:report $TEST_APP --format json | jq -r '.\"registry-global-image-repo-template\"'"
   assert_success
   assert_output 'dokku/{{ APP }}'
 
-  run /bin/bash -c "dokku --quiet registry:report $TEST_APP --format json | jq -r '.\"registry-computed-image-repo\"'"
+  run /bin/bash -c "dokku registry:report $TEST_APP --format json | jq -r '.\"registry-computed-image-repo\"'"
   assert_success
   assert_output "dokku/$TEST_APP"
 
   run /bin/bash -c "dokku registry:set $TEST_APP image-repo my/$TEST_APP"
   assert_success
 
-  run /bin/bash -c "dokku --quiet registry:report $TEST_APP --format json | jq -r '.\"registry-image-repo\"'"
+  run /bin/bash -c "dokku registry:report $TEST_APP --format json | jq -r '.\"registry-image-repo\"'"
   assert_success
   assert_output "my/$TEST_APP"
 
-  run /bin/bash -c "dokku --quiet registry:report $TEST_APP --format json | jq -r '.\"registry-computed-image-repo\"'"
+  run /bin/bash -c "dokku registry:report $TEST_APP --format json | jq -r '.\"registry-computed-image-repo\"'"
   assert_success
   assert_output "my/$TEST_APP"
 
@@ -185,37 +185,37 @@ teardown() {
   run /bin/bash -c "dokku registry:set --global push-on-release"
   assert_success
 
-  run /bin/bash -c "dokku --quiet registry:report $TEST_APP --format json | jq -r '.\"registry-push-on-release\"'"
+  run /bin/bash -c "dokku registry:report $TEST_APP --format json | jq -r '.\"registry-push-on-release\"'"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet registry:report $TEST_APP --format json | jq -r '.\"registry-global-push-on-release\"'"
+  run /bin/bash -c "dokku registry:report $TEST_APP --format json | jq -r '.\"registry-global-push-on-release\"'"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet registry:report $TEST_APP --format json | jq -r '.\"registry-computed-push-on-release\"'"
+  run /bin/bash -c "dokku registry:report $TEST_APP --format json | jq -r '.\"registry-computed-push-on-release\"'"
   assert_success
   assert_output "false"
 
   run /bin/bash -c "dokku registry:set --global push-on-release true"
   assert_success
 
-  run /bin/bash -c "dokku --quiet registry:report $TEST_APP --format json | jq -r '.\"registry-global-push-on-release\"'"
+  run /bin/bash -c "dokku registry:report $TEST_APP --format json | jq -r '.\"registry-global-push-on-release\"'"
   assert_success
   assert_output "true"
 
-  run /bin/bash -c "dokku --quiet registry:report $TEST_APP --format json | jq -r '.\"registry-computed-push-on-release\"'"
+  run /bin/bash -c "dokku registry:report $TEST_APP --format json | jq -r '.\"registry-computed-push-on-release\"'"
   assert_success
   assert_output "true"
 
   run /bin/bash -c "dokku registry:set $TEST_APP push-on-release false"
   assert_success
 
-  run /bin/bash -c "dokku --quiet registry:report $TEST_APP --format json | jq -r '.\"registry-push-on-release\"'"
+  run /bin/bash -c "dokku registry:report $TEST_APP --format json | jq -r '.\"registry-push-on-release\"'"
   assert_success
   assert_output "false"
 
-  run /bin/bash -c "dokku --quiet registry:report $TEST_APP --format json | jq -r '.\"registry-computed-push-on-release\"'"
+  run /bin/bash -c "dokku registry:report $TEST_APP --format json | jq -r '.\"registry-computed-push-on-release\"'"
   assert_success
   assert_output "false"
 
@@ -227,14 +227,14 @@ teardown() {
 }
 
 @test "(registry:report) push-extra-tags raw" {
-  run /bin/bash -c "dokku --quiet registry:report $TEST_APP --format json | jq -r '.\"registry-push-extra-tags\"'"
+  run /bin/bash -c "dokku registry:report $TEST_APP --format json | jq -r '.\"registry-push-extra-tags\"'"
   assert_success
   assert_output ""
 
   run /bin/bash -c "dokku registry:set $TEST_APP push-extra-tags release,stable"
   assert_success
 
-  run /bin/bash -c "dokku --quiet registry:report $TEST_APP --format json | jq -r '.\"registry-push-extra-tags\"'"
+  run /bin/bash -c "dokku registry:report $TEST_APP --format json | jq -r '.\"registry-push-extra-tags\"'"
   assert_success
   assert_output "release,stable"
 
diff --git a/tests/unit/scheduler.bats b/tests/unit/scheduler.bats
index c158be8b8..9cee44778 100644
--- a/tests/unit/scheduler.bats
+++ b/tests/unit/scheduler.bats
@@ -31,41 +31,41 @@ teardown() {
   run /bin/bash -c "dokku scheduler:set --global selected"
   assert_success
 
-  run /bin/bash -c "dokku --quiet scheduler:report $TEST_APP --format json | jq -r '.\"scheduler-selected\"'"
+  run /bin/bash -c "dokku scheduler:report $TEST_APP --format json | jq -r '.\"scheduler-selected\"'"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet scheduler:report $TEST_APP --format json | jq -r '.\"scheduler-global-selected\"'"
+  run /bin/bash -c "dokku scheduler:report $TEST_APP --format json | jq -r '.\"scheduler-global-selected\"'"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet scheduler:report $TEST_APP --format json | jq -r '.\"scheduler-computed-selected\"'"
+  run /bin/bash -c "dokku scheduler:report $TEST_APP --format json | jq -r '.\"scheduler-computed-selected\"'"
   assert_success
   assert_output "docker-local"
 
   run /bin/bash -c "dokku scheduler:set --global selected null"
   assert_success
 
-  run /bin/bash -c "dokku --quiet scheduler:report $TEST_APP --format json | jq -r '.\"scheduler-global-selected\"'"
+  run /bin/bash -c "dokku scheduler:report $TEST_APP --format json | jq -r '.\"scheduler-global-selected\"'"
   assert_success
   assert_output "null"
 
-  run /bin/bash -c "dokku --quiet scheduler:report $TEST_APP --format json | jq -r '.\"scheduler-computed-selected\"'"
+  run /bin/bash -c "dokku scheduler:report $TEST_APP --format json | jq -r '.\"scheduler-computed-selected\"'"
   assert_success
   assert_output "null"
 
   run /bin/bash -c "dokku scheduler:set $TEST_APP selected docker-local"
   assert_success
 
-  run /bin/bash -c "dokku --quiet scheduler:report $TEST_APP --format json | jq -r '.\"scheduler-selected\"'"
+  run /bin/bash -c "dokku scheduler:report $TEST_APP --format json | jq -r '.\"scheduler-selected\"'"
   assert_success
   assert_output "docker-local"
 
-  run /bin/bash -c "dokku --quiet scheduler:report $TEST_APP --format json | jq -r '.\"scheduler-global-selected\"'"
+  run /bin/bash -c "dokku scheduler:report $TEST_APP --format json | jq -r '.\"scheduler-global-selected\"'"
   assert_success
   assert_output "null"
 
-  run /bin/bash -c "dokku --quiet scheduler:report $TEST_APP --format json | jq -r '.\"scheduler-computed-selected\"'"
+  run /bin/bash -c "dokku scheduler:report $TEST_APP --format json | jq -r '.\"scheduler-computed-selected\"'"
   assert_success
   assert_output "docker-local"
 
@@ -80,18 +80,18 @@ teardown() {
   run /bin/bash -c "dokku scheduler:set --global selected"
   assert_success
 
-  run /bin/bash -c "dokku --quiet scheduler:report --global --format json | jq -e ."
+  run /bin/bash -c "dokku scheduler:report --global --format json | jq -e ."
   assert_success
 
-  run /bin/bash -c "dokku --quiet scheduler:report --global --format json | jq -r '.\"scheduler-global-selected\"'"
+  run /bin/bash -c "dokku scheduler:report --global --format json | jq -r '.\"scheduler-global-selected\"'"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet scheduler:report --global --format json | jq -r '.\"scheduler-computed-selected\"'"
+  run /bin/bash -c "dokku scheduler:report --global --format json | jq -r '.\"scheduler-computed-selected\"'"
   assert_success
   assert_output "docker-local"
 
-  run /bin/bash -c "dokku --quiet scheduler:report --global --format json | jq -r 'has(\"scheduler-selected\")'"
+  run /bin/bash -c "dokku scheduler:report --global --format json | jq -r 'has(\"scheduler-selected\")'"
   assert_success
   assert_output "false"
 }
diff --git a/tests/unit/storage.bats b/tests/unit/storage.bats
index 2f16abd91..a93c40428 100644
--- a/tests/unit/storage.bats
+++ b/tests/unit/storage.bats
@@ -185,30 +185,30 @@ teardown() {
 }
 
 @test "(storage:report) build/deploy/run mounts raw" {
-  run /bin/bash -c "dokku --quiet storage:report $TEST_APP --format json | jq -r '.\"storage-build-mounts\"'"
+  run /bin/bash -c "dokku storage:report $TEST_APP --format json | jq -r '.\"storage-build-mounts\"'"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet storage:report $TEST_APP --format json | jq -r '.\"storage-deploy-mounts\"'"
+  run /bin/bash -c "dokku storage:report $TEST_APP --format json | jq -r '.\"storage-deploy-mounts\"'"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet storage:report $TEST_APP --format json | jq -r '.\"storage-run-mounts\"'"
+  run /bin/bash -c "dokku storage:report $TEST_APP --format json | jq -r '.\"storage-run-mounts\"'"
   assert_success
   assert_output ""
 
   run /bin/bash -c "dokku storage:mount $TEST_APP /tmp/storage-mount:/mount"
   assert_success
 
-  run /bin/bash -c "dokku --quiet storage:report $TEST_APP --format json | jq -r '.\"storage-deploy-mounts\"'"
+  run /bin/bash -c "dokku storage:report $TEST_APP --format json | jq -r '.\"storage-deploy-mounts\"'"
   assert_success
   assert_output "-v /tmp/storage-mount:/mount"
 
-  run /bin/bash -c "dokku --quiet storage:report $TEST_APP --format json | jq -r '.\"storage-run-mounts\"'"
+  run /bin/bash -c "dokku storage:report $TEST_APP --format json | jq -r '.\"storage-run-mounts\"'"
   assert_success
   assert_output "-v /tmp/storage-mount:/mount"
 
-  run /bin/bash -c "dokku --quiet storage:report $TEST_APP --format json | jq -r '.\"storage-build-mounts\"'"
+  run /bin/bash -c "dokku storage:report $TEST_APP --format json | jq -r '.\"storage-build-mounts\"'"
   assert_success
   assert_output ""
 
diff --git a/tests/unit/traefik.bats b/tests/unit/traefik.bats
index 4d603fa27..ac9edf1b8 100644
--- a/tests/unit/traefik.bats
+++ b/tests/unit/traefik.bats
@@ -72,25 +72,25 @@ teardown() {
 }
 
 @test "(traefik:report) --global raw and computed keys in --format json" {
-  run /bin/bash -c "dokku --quiet traefik:report --global --format json | jq -r '.\"global-api-vhost\"'"
+  run /bin/bash -c "dokku traefik:report --global --format json | jq -r '.\"global-api-vhost\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet traefik:report --global --format json | jq -r '.\"computed-api-vhost\"'"
+  run /bin/bash -c "dokku traefik:report --global --format json | jq -r '.\"computed-api-vhost\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
   assert_output "traefik.dokku.me"
 
-  run /bin/bash -c "dokku --quiet traefik:report --global --format json | jq -r '.\"global-dashboard-enabled\"'"
+  run /bin/bash -c "dokku traefik:report --global --format json | jq -r '.\"global-dashboard-enabled\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
   assert_output ""
 
-  run /bin/bash -c "dokku --quiet traefik:report --global --format json | jq -r '.\"computed-dashboard-enabled\"'"
+  run /bin/bash -c "dokku traefik:report --global --format json | jq -r '.\"computed-dashboard-enabled\"'"
   echo "output: $output"
   echo "status: $status"
   assert_success
@@ -300,12 +300,12 @@ teardown() {
   assert_success
   assert_output "5000"
 
-  run /bin/bash -c "dokku --quiet ports:report $TEST_APP --ports-map"
+  run /bin/bash -c "dokku ports:report $TEST_APP --ports-map"
   echo "output: $output"
   echo "status: $status"
   assert_output_not_exists
 
-  run /bin/bash -c "dokku --quiet ports:report $TEST_APP --ports-map-detected"
+  run /bin/bash -c "dokku ports:report $TEST_APP --ports-map-detected"
   echo "output: $output"
   echo "status: $status"
   assert_output "http:80:5000 https:443:5000"