Honor NO_COLOR in the terminal log handler (closes #402)

The TTY log handler always wrote ANSI color, unlike internal/ui, which
disables color when NO_COLOR is set. Add a color flag to TTYHandler,
set from NO_COLOR with the same test internal/ui uses, and route every
color code through a paint helper that returns plain text when color is
off. The README's color sentence now covers log lines too.

Model: deepseek-v4-pro (implementation); opus-5-5 (rebase)

README.md

@@ -32,8 +32,8 @@ mkdir /Volumes/usbstick/mybackup
 # (System Settings → Privacy & Security → Full Disk Access), otherwise
 # the backup will abort with a permission error on protected directories
 
-# run your first backup (the default config backs up ~ and /Applications
-# with sensible excludes)
+# run your first backup (the default config backs up ~, and /Applications
+# on macOS only, with sensible excludes)
 vaultik snapshot create
 
 # see what you have
@@ -831,7 +831,8 @@ Work planned after 1.0. Loosely ordered by priority.
 
 Every command's user-facing output is governed by `internal/ui`, in one of two
 ways. Color is enabled when the stream written to is a TTY and the `NO_COLOR`
-environment variable is unset (https://no-color.org/).
+environment variable is unset (https://no-color.org/). The same rule governs the
+colorized log lines `internal/log` writes to a terminal.
 
 - **Status, progress, warnings, and errors** go through the `internal/ui`
   message methods below: marker-prefixed, colored on a TTY, and — except

docs/TODO.md

@@ -28,6 +28,16 @@ runs the release build in `.gitea/workflows/release.yml`.
   ([issue #411](https://git.eeqj.de/sneak/vaultik/issues/411)). The architecture
   document and this file moved to `docs/`, and the example config to `configs/`.
 
+- 2026-11-10: Printed the status and progress lines of `remote info` and
+  `snapshot verify` through `internal/ui`, with its marker and color, as the
+  README describes ([issue #410](https://git.eeqj.de/sneak/vaultik/issues/410)).
+  Their reports stay plain.
+
+- 2026-11-10: Made `config init` write the `apps` snapshot, which backs up
+  `/Applications`, only on macOS
+  ([issue #408](https://git.eeqj.de/sneak/vaultik/issues/408)). On Linux the
+  first `snapshot create` stopped on the missing directory.
+
 - 2026-10-15: Stopped `snapshot create --prune` pruning after a backup in which
   a volume mounted below a configured path in an earlier snapshot of the same
   name was not mounted

internal/cli/app.go

@@ -90,7 +90,7 @@ func setupGlobals(
 // blank line. Used both from the fx hook (for subcommand invocations) and
 // from the root cobra Run handler (for `vaultik` with no subcommand).
 func writeStartupBanner(w *ui.Writer, startTime time.Time, shortCommit string) {
-	w.Bannerf("%s %s by %s (commit %s, built on %s) starting up at %s.",
+	w.Bannerf("%s %s by %s (commit %s, commit date %s) starting up at %s.",
 		globals.Appname, globals.Version, globals.Author,
 		shortCommit, globals.CommitDate,
 		startTime.Format(time.RFC3339))

internal/cli/config.go

@@ -8,6 +8,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"reflect"
+	"runtime"
 	"slices"
 	"strconv"
 	"strings"
@@ -30,7 +31,7 @@ const configSetArgs = 2
 // parent config dirs (e.g. ~/.config) are conventionally traversable.
 const configDirMode = 0o755
 
-// configYAMLIndent matches the 2-space indentation of defaultConfigTemplate,
+// configYAMLIndent matches the 2-space indentation of the default config,
 // so `config set` writes the file back with the same indentation rather than
 // yaml.Marshal's 4-space default.
 const configYAMLIndent = 2
@@ -50,7 +51,22 @@ var (
 			"so the file was not changed")
 )
 
-const defaultConfigTemplate = `# vaultik configuration
+// macOS is the value of runtime.GOOS on macOS.
+const macOS = "darwin"
+
+// defaultConfigText returns the file `config init` writes on the operating
+// system goos, named as runtime.GOOS names it. Only macOS gets the apps
+// snapshot, since /Applications exists nowhere else.
+func defaultConfigText(goos string) string {
+	if goos == macOS {
+		return defaultConfigHead + appsSnapshotConfig + defaultConfigTail
+	}
+
+	return defaultConfigHead + defaultConfigTail
+}
+
+// defaultConfigHead is the default config up to the end of the home snapshot.
+const defaultConfigHead = `# vaultik configuration
 # Documentation: https://sneak.berlin/go/vaultik
 
 # ─── REQUIRED ────────────────────────────────────────────────────────────────
@@ -168,7 +184,10 @@ snapshots:
       - "/Movies/ProxyMedia"
       - "/Music/iTunes/Album Artwork"
       - "/Pictures/iPod Photo Cache"
+`
 
+// appsSnapshotConfig is the apps snapshot of the default config.
+const appsSnapshotConfig = `
   # Third-party applications. OS-provided apps live in /System/Applications
   # on modern macOS and are never in /Applications, but Apple-installed
   # App Store apps (Safari, GarageBand, iWork, iMovie) are excluded since
@@ -189,7 +208,10 @@ snapshots:
       - "/Steam.app"
       - "/VirtualBox.app"
       - "/Utilities/Adobe Installers"
+`
 
+// defaultConfigTail is the default config after the snapshots.
+const defaultConfigTail = `
 # Storage backend (pick ONE of the three forms below).
 #
 # S3-compatible:
@@ -311,7 +333,8 @@ on macOS, ~/.config/ on Linux, /etc/vaultik/ as root).`,
 				return fmt.Errorf("creating config directory %s: %w", dir, err)
 			}
 
-			err = os.WriteFile(path, []byte(defaultConfigTemplate), configFileMode)
+			err = os.WriteFile(path, []byte(defaultConfigText(runtime.GOOS)),
+				configFileMode)
 			if err != nil {
 				return fmt.Errorf("writing config file: %w", err)
 			}
@@ -560,7 +583,7 @@ func yamlPathOnly(root *yaml.Node, keys []string) (*yaml.Node, error) {
 }
 
 // marshalConfigYAML renders a config document tree with 2-space indentation,
-// matching defaultConfigTemplate. yaml.Marshal defaults to 4 spaces, which
+// matching the default config. yaml.Marshal defaults to 4 spaces, which
 // would reindent the whole file on the first `config set` despite the promise
 // to preserve formatting.
 func marshalConfigYAML(root *yaml.Node) ([]byte, error) {

internal/cli/config_test.go

@@ -13,14 +13,15 @@ import (
 	"sneak.berlin/go/vaultik/internal/ui"
 )
 
-// TestDefaultConfigTemplateParses ensures the init template is valid YAML
-// that unmarshals into the Config struct with the expected snapshots.
-func TestDefaultConfigTemplateParses(t *testing.T) {
+// TestDefaultConfigParsesOnMacOS ensures the config `config init` writes on
+// macOS is valid YAML that unmarshals into the Config struct with the
+// expected snapshots.
+func TestDefaultConfigParsesOnMacOS(t *testing.T) {
 	t.Parallel()
 
 	var cfg config.Config
 
-	err := yaml.Unmarshal([]byte(defaultConfigTemplate), &cfg)
+	err := yaml.Unmarshal([]byte(defaultConfigText("darwin")), &cfg)
 	if err != nil {
 		t.Fatalf("default config template is not valid YAML: %v", err)
 	}
@@ -58,6 +59,39 @@ func TestDefaultConfigTemplateParses(t *testing.T) {
 	}
 }
 
+// TestDefaultConfigOnLinux checks that the config `config init` writes on
+// Linux loads with its home snapshot and without the apps snapshot, whose
+// /Applications exists only on macOS.
+func TestDefaultConfigOnLinux(t *testing.T) {
+	t.Parallel()
+
+	path := filepath.Join(t.TempDir(), "config.yml")
+
+	err := os.WriteFile(path, []byte(defaultConfigText("linux")), configFileMode)
+	if err != nil {
+		t.Fatalf("write config: %v", err)
+	}
+
+	err = writeConfigSet(ui.NewWithColor(&bytes.Buffer{}, false),
+		path, "storage_url", "file:///mnt/backups")
+	if err != nil {
+		t.Fatalf("config set storage_url: %v", err)
+	}
+
+	cfg, err := config.Load(path)
+	if err != nil {
+		t.Fatalf("config.Load: %v", err)
+	}
+
+	if _, ok := cfg.Snapshots["home"]; !ok {
+		t.Error("expected 'home' snapshot in the Linux default config")
+	}
+
+	if _, ok := cfg.Snapshots["apps"]; ok {
+		t.Error("the Linux default config should have no 'apps' snapshot")
+	}
+}
+
 // testRecipient is a valid age public key.
 const testRecipient = "age1278m9q7dp3chsh2dcy82qk27v047zywyvtxwnj4cvt0z65jw6a7q5dqhfj"
 
@@ -71,7 +105,7 @@ func TestConfigSetRecipientOnFreshConfig(t *testing.T) {
 
 	path := filepath.Join(t.TempDir(), "config.yml")
 
-	err := os.WriteFile(path, []byte(defaultConfigTemplate), configFileMode)
+	err := os.WriteFile(path, []byte(defaultConfigText(macOS)), configFileMode)
 	if err != nil {
 		t.Fatalf("write config: %v", err)
 	}
@@ -220,7 +254,7 @@ func TestConfigSetKeepsFileThatWouldNotLoad(t *testing.T) {
 		{levelReference, "blob_size_limit", "1MB",
 			"blob_size_limit must be at least"},
 		// The type check on a config that does not load yet.
-		{defaultConfigTemplate, "snapshots.apps.paths", "/srv",
+		{defaultConfigText(macOS), "snapshots.apps.paths", "/srv",
 			"into []string"},
 		// The type check on a config that cannot be read here.
 		{configWithUnsetReference, "snapshots.home.paths", "/x",
@@ -380,7 +414,7 @@ func loadAfterConfigSet(t *testing.T, key, value string) *config.Config {
 
 	path := filepath.Join(t.TempDir(), "config.yml")
 
-	err := os.WriteFile(path, []byte(defaultConfigTemplate), configFileMode)
+	err := os.WriteFile(path, []byte(defaultConfigText(macOS)), configFileMode)
 	if err != nil {
 		t.Fatalf("write config: %v", err)
 	}

internal/cli/entry_banner_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/adrg/xdg"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/vaultik/internal/globals"
 )
 
 // Command words and flags used to build argument vectors below. They are
@@ -112,6 +113,35 @@ func TestBannerStillPrintedWithoutSuppressingFlag(t *testing.T) {
 	}
 }
 
+// TestBannerLabelsCommitDate checks that the banner prints the commit
+// and the commit date, each after its own label. Commit and CommitDate
+// get different values, so printing the wrong one fails.
+//
+//nolint:paralleltest // sets globals.Commit and globals.CommitDate
+func TestBannerLabelsCommitDate(t *testing.T) {
+	const (
+		commit     = "abc1234"
+		commitDate = "2026-11-09"
+	)
+
+	previousCommit, previousCommitDate := globals.Commit, globals.CommitDate
+
+	t.Cleanup(func() {
+		globals.Commit = previousCommit
+		globals.CommitDate = previousCommitDate
+	})
+
+	globals.Commit = commit
+	globals.CommitDate = commitDate
+
+	var banner bytes.Buffer
+
+	emitStartupBanner(nil, &banner)
+
+	assert.Contains(t, banner.String(),
+		"(commit "+commit+", commit date "+commitDate+")")
+}
+
 // TestBannerSuppressedInArgs covers the suppression scan directly,
 // including the flags that suppressed the banner before --json joined
 // them, so that adding --json cannot regress them.

internal/cli/version.go

@@ -37,13 +37,13 @@ func writeVersion(out *ui.Writer) {
 	w := out.Out()
 
 	_, _ = fmt.Fprintf(w, "vaultik %s\n", globals.Version)
-	_, _ = fmt.Fprintf(w, "  commit:     %s\n", globals.Commit)
-	_, _ = fmt.Fprintf(w, "  build date: %s\n", globals.CommitDate)
-	_, _ = fmt.Fprintf(w, "  go:         %s\n", runtime.Version())
-	_, _ = fmt.Fprintf(w, "  os/arch:    %s/%s\n", runtime.GOOS, runtime.GOARCH)
-	_, _ = fmt.Fprintf(w, "  author:     %s\n", globals.Author)
-	_, _ = fmt.Fprintf(w, "  homepage:   %s\n", globals.Homepage)
-	_, _ = fmt.Fprintf(w, "  license:    %s\n", globals.License)
+	_, _ = fmt.Fprintf(w, "  commit:      %s\n", globals.Commit)
+	_, _ = fmt.Fprintf(w, "  commit date: %s\n", globals.CommitDate)
+	_, _ = fmt.Fprintf(w, "  go:          %s\n", runtime.Version())
+	_, _ = fmt.Fprintf(w, "  os/arch:     %s/%s\n", runtime.GOOS, runtime.GOARCH)
+	_, _ = fmt.Fprintf(w, "  author:      %s\n", globals.Author)
+	_, _ = fmt.Fprintf(w, "  homepage:    %s\n", globals.Homepage)
+	_, _ = fmt.Fprintf(w, "  license:     %s\n", globals.License)
 
 	if globals.IsDevVersion(globals.Version) {
 		_, _ = fmt.Fprintln(w)

internal/cli/version_test.go

@@ -2,6 +2,7 @@ package cli_test
 
 import (
 	"bytes"
+	"runtime"
 	"strings"
 	"testing"
 
@@ -49,6 +50,42 @@ func TestVersionCommandReportsBuildVersion(t *testing.T) {
 	}
 }
 
+// TestVersionCommandReportLines checks the label, padding and value of
+// every line of the report. Commit and CommitDate get different values,
+// so a line that prints the wrong one fails.
+//
+//nolint:paralleltest // sets globals.Commit and globals.CommitDate
+func TestVersionCommandReportLines(t *testing.T) {
+	const (
+		commit     = "abc1234"
+		commitDate = "2026-11-09"
+	)
+
+	previousCommit, previousCommitDate := globals.Commit, globals.CommitDate
+
+	t.Cleanup(func() {
+		globals.Commit = previousCommit
+		globals.CommitDate = previousCommitDate
+	})
+
+	globals.Commit = commit
+	globals.CommitDate = commitDate
+
+	want := "vaultik " + globals.Version + "\n" +
+		"  commit:      " + commit + "\n" +
+		"  commit date: " + commitDate + "\n" +
+		"  go:          " + runtime.Version() + "\n" +
+		"  os/arch:     " + runtime.GOOS + "/" + runtime.GOARCH + "\n" +
+		"  author:      " + globals.Author + "\n" +
+		"  homepage:    " + globals.Homepage + "\n" +
+		"  license:     " + globals.License + "\n"
+
+	out := runVersionCommand(t)
+	if !strings.HasPrefix(out, want) {
+		t.Errorf("report:\n%s\nwant it to start with:\n%s", out, want)
+	}
+}
+
 // TestVersionCommandFlagsDevelopmentBuild is the regression test for
 // the thing this command exists to prevent: a build that is not a
 // release must say so. The notice used to be gated on the version

internal/log/tty_handler.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io"
 	"log/slog"
+	"os"
 	"strconv"
 	"strings"
 	"sync"
@@ -60,6 +61,12 @@ type TTYHandler struct {
 	mu   *sync.Mutex
 	out  io.Writer
 
+	// color reports whether records are written with ANSI color. It is
+	// false when NO_COLOR is set, matching internal/ui's shouldColor
+	// test; the caller already chose this handler for a terminal, so
+	// TTY-ness is not re-checked here.
+	color bool
+
 	// attrs are the attributes accumulated through WithAttrs, emitted
 	// ahead of each record's own attributes. Their keys already carry
 	// the group path that was open when they were added, so no
@@ -72,16 +79,19 @@ type TTYHandler struct {
 	groups []string
 }
 
-// NewTTYHandler creates a new TTY handler with colored output.
+// NewTTYHandler creates a new TTY handler. Color is enabled unless the
+// NO_COLOR environment variable is set to a non-empty value, the same
+// test internal/ui applies to status lines.
 func NewTTYHandler(out io.Writer, opts *slog.HandlerOptions) *TTYHandler {
 	if opts == nil {
 		opts = &slog.HandlerOptions{}
 	}
 
 	return &TTYHandler{
-		out:  out,
-		opts: *opts,
-		mu:   &sync.Mutex{},
+		out:   out,
+		opts:  *opts,
+		mu:    &sync.Mutex{},
+		color: os.Getenv("NO_COLOR") == "",
 	}
 }
 
@@ -124,10 +134,10 @@ func (h *TTYHandler) Handle(_ context.Context, r slog.Record) error {
 	// are written around it: it can carry text from an untrusted source
 	// (a storage error, for one), and a raw control character would
 	// otherwise reach the terminal.
-	_, _ = fmt.Fprintf(h.out, "%s%s%s %s%s%s %s%s%s",
-		colorGray, timestamp, colorReset,
-		levelColor, level, colorReset,
-		colorBold, sanitize(r.Message), colorReset)
+	_, _ = fmt.Fprintf(h.out, "%s %s %s",
+		h.paint(colorGray, timestamp),
+		h.paint(levelColor, level),
+		h.paint(colorBold, sanitize(r.Message)))
 
 	// Attributes carried by the handler come first, then the record's
 	// own. Handler attributes were qualified when they were added; the
@@ -236,6 +246,7 @@ func (h *TTYHandler) clone() *TTYHandler {
 		opts:   h.opts,
 		mu:     h.mu,
 		out:    h.out,
+		color:  h.color,
 		attrs:  make([]slog.Attr, len(h.attrs), len(h.attrs)+1),
 		groups: make([]string, len(h.groups), len(h.groups)+1),
 	}
@@ -273,9 +284,19 @@ func (h *TTYHandler) writeAttr(a slog.Attr) {
 	// the snapshot database — so a control character in one of them must
 	// be rendered as an escape sequence rather than reaching the terminal,
 	// where it could move the cursor or inject its own colours.
-	_, _ = fmt.Fprintf(h.out, " %s%s%s=%s%s%s",
-		colorCyan, sanitize(a.Key), colorReset,
-		colorBlue, sanitize(value), colorReset)
+	_, _ = fmt.Fprintf(h.out, " %s=%s",
+		h.paint(colorCyan, sanitize(a.Key)),
+		h.paint(colorBlue, sanitize(value)))
+}
+
+// paint wraps s in the given ANSI color when color is enabled, and
+// returns s unchanged otherwise.
+func (h *TTYHandler) paint(color, s string) string {
+	if !h.color {
+		return s
+	}
+
+	return color + s + colorReset
 }
 
 // sanitize returns s unchanged when every rune in it is printable, and a

internal/log/tty_handler_test.go

@@ -421,3 +421,44 @@ func TestTTYHandlerEmptyGroupAndAttrsAreNoOps(t *testing.T) {
 	assert.Contains(t, plain, "kept=yes")
 	assert.NotContains(t, plain, " =")
 }
+
+// TestTTYHandlerRespectsNoColor checks that only a non-empty NO_COLOR
+// turns color off, matching internal/ui's shouldColor test. The handler
+// is only ever chosen for a terminal, so this is the one remaining
+// condition that can still leave color in log output.
+func TestTTYHandlerRespectsNoColor(t *testing.T) {
+	cases := []struct {
+		name    string
+		noColor string
+		colored bool
+	}{
+		{
+			name:    "NO_COLOR turns color off",
+			noColor: "1",
+		},
+		{
+			name:    "empty NO_COLOR keeps color on",
+			noColor: "",
+			colored: true,
+		},
+	}
+
+	for _, testCase := range cases {
+		t.Run(testCase.name, func(t *testing.T) {
+			t.Setenv("NO_COLOR", testCase.noColor)
+
+			var buf bytes.Buffer
+
+			logger := slog.New(log.NewTTYHandler(&buf, debugHandlerOptions()))
+			logger.Info("hello", "key", "value")
+
+			if testCase.colored {
+				assert.Contains(t, buf.String(), "\x1b[",
+					"an empty NO_COLOR must leave ANSI color in log output")
+			} else {
+				assert.NotContains(t, buf.String(), "\x1b[",
+					"NO_COLOR must suppress every ANSI escape in log output")
+			}
+		})
+	}
+}

internal/vaultik/info.go

@@ -246,7 +246,7 @@ func (v *Vaultik) RemoteInfo(jsonOutput bool) error {
 		v.stdoutf("Type:     %s\n", storageInfo.Type)
 		v.stdoutf("Location: %s\n", storageInfo.Location)
 		v.printlnStdout()
-		v.stdoutf("Scanning snapshot metadata...\n")
+		v.UI.Beginf("Scanning snapshot metadata...")
 	}
 
 	snapshotMetadata, snapshotIDs, skippedManifestCount, err := v.collectSnapshotMetadata()
@@ -265,7 +265,7 @@ func (v *Vaultik) RemoteInfo(jsonOutput bool) error {
 			}
 		}
 
-		v.stdoutf("Downloading %d manifest(s)...\n", manifestCount)
+		v.UI.Beginf("Downloading %d manifest(s)...", manifestCount)
 	}
 
 	referencedBlobs, unreadableManifests := v.collectReferencedBlobsFromManifests(
@@ -447,7 +447,7 @@ func (v *Vaultik) scanRemoteBlobStorage(
 	result *RemoteInfoResult, referencedBlobs map[string]int64, showText bool,
 ) error {
 	if showText {
-		v.stdoutf("Scanning blobs...\n")
+		v.UI.Beginf("Scanning blobs...")
 	}
 
 	// Use prune's listing, so a file under blobs/ that prune would never

internal/vaultik/remote_info_test.go

@@ -12,6 +12,7 @@ import (
 	"github.com/stretchr/testify/require"
 	"sneak.berlin/go/vaultik/internal/log"
 	"sneak.berlin/go/vaultik/internal/snapshot"
+	"sneak.berlin/go/vaultik/internal/ui"
 )
 
 // testBlobHashB is a blob that the manifest written by addRemote does
@@ -259,3 +260,24 @@ func TestRemoteInfo_DirectoryWithoutManifestLeavesOrphansKnown(t *testing.T) {
 	assert.NotContains(t, doc, "unreadable_manifests")
 	assert.NotContains(t, doc, "skipped_manifest_count")
 }
+
+// TestRemoteInfo_StatusLineUsesUIMarker checks that the remote info
+// status lines go through internal/ui: marker-prefixed, and silenced by
+// --quiet.
+func TestRemoteInfo_StatusLineUsesUIMarker(t *testing.T) {
+	log.Initialize(log.Config{})
+	t.Parallel()
+
+	env := newListEnv(t)
+	env.addRemote(t, listRemoteID, time.Date(2026, 3, 2, 0, 0, 0, 0, time.UTC))
+
+	const statusLine = ui.Marker + " Scanning snapshot metadata...\n"
+
+	require.NoError(t, env.v.RemoteInfo(false))
+	assert.Contains(t, env.stdout.String(), statusLine)
+
+	env.stdout.Reset()
+	env.v.UI.SetQuiet(true)
+	require.NoError(t, env.v.RemoteInfo(false))
+	assert.NotContains(t, env.stdout.String(), "Scanning snapshot metadata")
+}

internal/vaultik/snapshot.go

@@ -1019,7 +1019,7 @@ func (v *Vaultik) VerifySnapshotWithOptions(
 		v.printlnStdout()
 
 		// Check each blob is present with the size the manifest records.
-		v.stdoutf("Checking blob presence and sizes...\n")
+		v.UI.Beginf("Checking blob presence and sizes...")
 	}
 
 	v.checkSnapshotDatabase(remoteKey, result)

internal/vaultik/verify.go

@@ -190,7 +190,7 @@ func (v *Vaultik) loadVerificationData(
 	log.Info("Downloading manifest", "remote_key", remoteKey)
 
 	if !opts.JSON && !v.UI.Quiet() {
-		v.stdoutf("Downloading manifest...\n")
+		v.UI.Beginf("Downloading manifest...")
 	}
 
 	manifest, err := v.downloadManifestByKey(remoteKey)
@@ -205,9 +205,9 @@ func (v *Vaultik) loadVerificationData(
 		"manifest_total_size", ubytes(manifest.TotalCompressedSize))
 
 	if !opts.JSON && !v.UI.Quiet() {
-		v.stdoutf("Manifest loaded: %d blobs (%s)\n",
+		v.UI.Completef("Manifest loaded: %d blobs (%s)",
 			manifest.BlobCount, ubytes(manifest.TotalCompressedSize))
-		v.stdoutf("Downloading and decrypting database...\n")
+		v.UI.Beginf("Downloading and decrypting database...")
 	}
 
 	tdb, err := v.downloadVerifiedSnapshotDB(
@@ -235,7 +235,7 @@ func (v *Vaultik) loadVerificationData(
 		"db_total_size", ubytes(dbTotalSize))
 
 	if !opts.JSON && !v.UI.Quiet() {
-		v.stdoutf("Database loaded: %d blobs (%s)\n",
+		v.UI.Completef("Database loaded: %d blobs (%s)",
 			len(dbBlobs), ubytes(dbTotalSize))
 	}
 
@@ -295,7 +295,7 @@ func (v *Vaultik) runVerificationSteps(
 	identities []age.Identity,
 ) error {
 	if !opts.JSON && !v.UI.Quiet() {
-		v.stdoutf("Verifying manifest against database...\n")
+		v.UI.Beginf("Verifying manifest against database...")
 	}
 
 	err := v.verifyManifestAgainstDatabase(manifest, dbBlobs)
@@ -304,8 +304,8 @@ func (v *Vaultik) runVerificationSteps(
 	}
 
 	if !opts.JSON && !v.UI.Quiet() {
-		v.stdoutf("Manifest verified.\n")
-		v.stdoutf("Checking blob existence in remote storage...\n")
+		v.UI.Completef("Manifest verified.")
+		v.UI.Beginf("Checking blob existence in remote storage...")
 	}
 
 	err = v.verifyBlobExistenceFromDB(dbBlobs, result)
@@ -314,8 +314,8 @@ func (v *Vaultik) runVerificationSteps(
 	}
 
 	if !opts.JSON && !v.UI.Quiet() {
-		v.stdoutf("All blobs exist.\n")
-		v.stdoutf("Downloading and verifying blob contents (%d blobs, %s)...\n",
+		v.UI.Completef("All blobs exist.")
+		v.UI.Beginf("Downloading and verifying blob contents (%d blobs, %s)...",
 			len(dbBlobs), ubytes(totalSize))
 	}
 
@@ -790,7 +790,7 @@ func (v *Vaultik) performDeepVerificationFromDB(
 		)
 
 		if !opts.JSON && !v.UI.Quiet() {
-			v.stdoutf("  Verified %d/%d blobs (%d remaining) - %s/%s - elapsed %s, eta %s\n",
+			v.UI.Progressf("Verified %d/%d blobs (%d remaining) - %s/%s - elapsed %s, eta %s",
 				i+1, len(blobs), remaining,
 				ubytes(bytesProcessed),
 				ubytes(totalBytesExpected),

internal/vaultik/verify_quiet_test.go

@@ -100,3 +100,51 @@ func TestVerify_QuietSuppressesReport(t *testing.T) {
 	require.Empty(t, stdout.String(),
 		"a failed verify must write no report under --quiet")
 }
+
+// TestVerify_DeepStatusLineUsesUIMarker checks that the deep verify
+// status lines go through internal/ui: marker-prefixed, and silenced by
+// --quiet.
+func TestVerify_DeepStatusLineUsesUIMarker(t *testing.T) {
+	log.Initialize(log.Config{})
+	t.Parallel()
+
+	fs := afero.NewOsFs()
+	tempDir := t.TempDir()
+
+	dataDir := filepath.Join(tempDir, "source")
+	storeDir := t.TempDir()
+	dbPath := filepath.Join(tempDir, "index.sqlite")
+
+	require.NoError(t, fs.MkdirAll(dataDir, 0o755))
+	require.NoError(t, afero.WriteFile(fs,
+		filepath.Join(dataDir, "data.bin"),
+		bytesPattern("marker-", 64*1024), 0o644))
+
+	ctx := context.Background()
+
+	cfg, storer, snapshotID := runFileStorageBackup(
+		ctx, t, fs, dataDir, storeDir, dbPath, 32*1024, 128*1024)
+
+	var stdout bytes.Buffer
+
+	v := &vaultik.Vaultik{
+		Config:  cfg,
+		Storage: storer,
+		Fs:      fs,
+		Stdout:  &stdout,
+		Stderr:  io.Discard,
+		UI:      ui.NewWithColor(&stdout, false),
+	}
+	v.SetContext(ctx)
+
+	opts := &vaultik.VerifyOptions{Deep: true}
+
+	require.NoError(t, v.VerifySnapshotWithOptions(snapshotID, opts))
+	require.Contains(t, stdout.String(),
+		"\n"+ui.Marker+" Downloading manifest...\n")
+
+	stdout.Reset()
+	v.UI.SetQuiet(true)
+	require.NoError(t, v.VerifySnapshotWithOptions(snapshotID, opts))
+	require.NotContains(t, stdout.String(), "Downloading manifest")
+}