feat(push): quiet, threshold-gated pre-push checkpoint progress

Rework of the pre-push checkpoint-sync progress UX so it is useful to a
human at a terminal but silent for the agents and CI that actually run
most `git push`es. Now that git-refs is the default checkpoint backend,
the old path printed an unconditional "[entire] Pushing N checkpoint
ref(s)..." line plus a dot spinner to stderr that nothing downstream reads.

- New pushReporter: presence-gated on IsTerminalWriter (non-TTY writes
  zero bytes), reveals a single in-place line only after a ~2s threshold,
  and clears it on completion (no scrollback residue).
- git-refs default path (flushCheckpointRefsQueue) rewired to the reporter;
  removed the now-dead startProgressDots.
- git --progress transfer detail routed to .entire/logs/ (operational
  metadata only) on BOTH backends, regardless of TTY.
- Legacy git-branch path also silenced for non-TTY; error/actionable-hint
  lines still print unconditionally on both paths.
- Push semantics unchanged (display only, fast-forward-only, never blocks
  the user's push).

Builds on and supersedes #1684.

Co-Authored-By: snowingfox <snowingfox@users.noreply.github.com>
Entire-Checkpoint: 01KYW08431VR6EKA854NP1A0SR

Author: gtrrz-victor

cmd/entire/cli/checkpoint/remote/git.go

@@ -1,6 +1,7 @@
 package remote
 
 import (
+	"bytes"
 	"context"
 	"encoding/base64"
 	"errors"
@@ -403,7 +404,8 @@ func FetchBlobs(ctx context.Context, remote string, hashes []string) error {
 
 // PushResult holds raw porcelain output from git push.
 type PushResult struct {
-	Output string
+	Output string // stdout (porcelain status lines)
+	Stderr string // stderr (git --progress transfer lines)
 }
 
 // PushOptions configures a git push operation.
@@ -431,7 +433,7 @@ func PushWithOptions(ctx context.Context, opts PushOptions) (PushResult, error)
 		return PushResult{}, fmt.Errorf("resolve push target: %w", err)
 	}
 
-	args := []string{"push", "--no-verify", "--porcelain"}
+	args := []string{"push", "--no-verify", "--porcelain", "--progress"}
 	args = append(args, opts.ExtraArgs...)
 	args = append(args, pushTarget)
 	args = append(args, opts.RefSpecs...)
@@ -441,11 +443,27 @@ func PushWithOptions(ctx context.Context, opts PushOptions) (PushResult, error)
 		cmd.Dir = opts.Dir
 	}
 	disableTerminalPrompt(cmd)
-	output, err := cmd.CombinedOutput()
+
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err = cmd.Run()
+	result := PushResult{
+		Output: stdout.String(),
+		Stderr: stderr.String(),
+	}
 	if err != nil {
-		return PushResult{Output: string(output)}, fmt.Errorf("git push: %w", err)
+		combined := stdout.String()
+		if stderr.Len() > 0 {
+			if combined != "" {
+				combined += "\n"
+			}
+			combined += stderr.String()
+		}
+		result.Output = combined
+		return result, fmt.Errorf("git push: %w", err)
 	}
-	return PushResult{Output: string(output)}, nil
+	return result, nil
 }
 
 // LsRemoteInDir is like LsRemote but runs in a specific directory.

cmd/entire/cli/strategy/common.go

@@ -227,7 +227,7 @@ func replayLocalCommits(ctx context.Context, repo *git.Repository, localRefName
 		return setRefHash(repo, localRefName, targetHash)
 	}
 
-	newTip, err := cherryPickOnto(ctx, repo, targetHash, localCommits, shallow)
+	newTip, err := cherryPickOnto(ctx, repo, targetHash, localCommits, shallow, nil)
 	if err != nil {
 		return fmt.Errorf("failed to replay local commits for %s: %w", localRefName, err)
 	}

cmd/entire/cli/strategy/manual_commit_push.go

@@ -9,14 +9,18 @@ import (
 	"os"
 	"os/exec"
 	"strings"
+	"time"
 
 	git "github.com/go-git/go-git/v6"
 	"github.com/go-git/go-git/v6/plumbing"
 
 	"github.com/entireio/cli/cmd/entire/cli/checkpoint"
 	checkpointremote "github.com/entireio/cli/cmd/entire/cli/checkpoint/remote"
+	"github.com/entireio/cli/cmd/entire/cli/interactive"
 	"github.com/entireio/cli/cmd/entire/cli/logging"
+	"github.com/entireio/cli/cmd/entire/cli/paths"
 	"github.com/entireio/cli/cmd/entire/cli/settings"
+	"github.com/entireio/cli/cmd/entire/cli/trailers"
 	"github.com/entireio/cli/perf"
 	"github.com/entireio/cli/redact"
 )
@@ -105,6 +109,13 @@ func (s *ManualCommitStrategy) prePush(ctx context.Context, remote string, prote
 		}
 	}
 
+	// Session-tree summary is progress, not an error/hint — skip the git-log
+	// work entirely on non-TTY stderr (agents/CI) instead of computing it only
+	// to have pushProgressOutput() discard it.
+	if interactive.IsTerminalWriter(os.Stderr) {
+		printPushSummary(ctx, remote, ps.pushTarget())
+	}
+
 	// OPF pre-push rewrite: if OPF is configured, resolve the user's
 	// decision (env > settings > prompt > non-TTY auto-run), then
 	// re-redact unpushed v1 commits with OPF (producing the OPF-applied,
@@ -351,30 +362,30 @@ func flushCheckpointRefsQueue(ctx context.Context, repo *git.Repository, pushTar
 	}
 
 	// Progress: pushing many refs over the network can take tens of seconds, so
-	// surface it (matching the v1 path's "[entire] Pushing ..." line) instead of
-	// leaving the user's git push apparently hung. Written to stderr, which git
-	// shows during the pre-push hook.
+	// surface it via the threshold-gated reporter instead of leaving the user's
+	// git push apparently hung. TTY-gated and threshold-delayed: agents and CI
+	// (non-TTY stderr) see zero progress bytes.
 	displayTarget := displayPushTarget(pushTarget)
-	fmt.Fprintf(os.Stderr, "[entire] Pushing %d checkpoint ref(s) to %s...", len(existing), displayTarget)
-	stop := startProgressDots(os.Stderr)
+	rep := newPushReporter(ctx, os.Stderr, interactive.IsTerminalWriter(os.Stderr), 2*time.Second)
+	rep.phase(fmt.Sprintf("syncing %d checkpoint(s) to %s", len(existing), displayTarget))
 
 	// Fast path: push all refs in one round-trip (fast-forward-only). If every
 	// ref was up to date or fast-forwarded, we're done.
 	batchErr := batchPushRefs(pushCtx, pushTarget, existing)
 	if batchErr == nil {
-		stop(" done")
+		rep.finish(fmt.Sprintf("pushed %d checkpoint(s)", len(existing)))
 		if removeErr := queue.Remove(existing); removeErr != nil {
 			logging.Warn(ctx, "git-refs push: clear pushed refs from queue failed",
 				slog.String("error", removeErr.Error()))
 		}
 		return len(existing), nil
 	}
-	stop("")
 
 	// Non-interactive SSH auth failures cannot be fixed by per-ref
 	// fetch+replay. Surface the same actionable hint as the v1 doPushRef path
 	// (issue #1523) instead of only logging to .entire/logs/.
 	if nonInteractiveSSHAuthFailure(pushCtx, batchErr) {
+		rep.finish("")
 		fmt.Fprintf(os.Stderr, "[entire] Warning: couldn't push checkpoint refs: %v\n", batchErr)
 		printNonInteractiveSSHAuthHint()
 		printCheckpointRemoteHint(pushTarget)
@@ -386,8 +397,7 @@ func flushCheckpointRefsQueue(ctx context.Context, repo *git.Repository, pushTar
 	// fetch+replay recovery, and remove from the queue only the refs that land
 	// (a genuine cherry-pick conflict leaves that ref queued for a later push,
 	// never force-overwriting the remote).
-	fmt.Fprintf(os.Stderr, "[entire] Some checkpoint refs diverged; syncing %d ref(s) individually...", len(existing))
-	stop = startProgressDots(os.Stderr)
+	rep.phase(fmt.Sprintf("resolving %d diverged checkpoint(s)", len(existing)))
 	pushed := make([]plumbing.ReferenceName, 0, len(existing))
 	var firstErr error
 	for _, ref := range existing {
@@ -404,7 +414,7 @@ func flushCheckpointRefsQueue(ctx context.Context, repo *git.Repository, pushTar
 		}
 		pushed = append(pushed, ref)
 	}
-	stop(fmt.Sprintf(" pushed %d of %d", len(pushed), len(existing)))
+	rep.finish(fmt.Sprintf("pushed %d of %d checkpoint(s)", len(pushed), len(existing)))
 	if err := queue.Remove(pushed); err != nil {
 		logging.Warn(ctx, "git-refs push: clear pushed refs from queue failed",
 			slog.String("error", err.Error()))
@@ -430,3 +440,66 @@ func cleanupPushedShadowBranches(ctx context.Context) {
 		)
 	}
 }
+
+// printPushSummary writes a session-level summary of pending checkpoint commits.
+// Silent on any failure — never blocks the push.
+func printPushSummary(ctx context.Context, remoteName, target string) {
+	repoRoot, err := paths.WorktreeRoot(ctx)
+	if err != nil {
+		return
+	}
+
+	branchName := paths.MetadataBranchName
+	logFormat := "%H|%s|%(trailers:key=" + trailers.SessionTrailerKey + ",valueonly,separator=%x20)|%aI"
+
+	var logOutput string
+	isNewBranch := false
+
+	if !checkpointremote.IsURL(target) {
+		rangeSpec := "refs/remotes/" + remoteName + "/" + branchName + "..refs/heads/" + branchName
+		firstOut, firstErr := runPushSummaryGitLog(ctx, repoRoot, logFormat, rangeSpec)
+		if firstErr == nil && strings.TrimSpace(firstOut) != "" {
+			logOutput = firstOut
+		} else {
+			fallbackOut, fallbackErr := runPushSummaryGitLog(ctx, repoRoot, logFormat, "refs/heads/"+branchName)
+			if fallbackErr == nil && strings.TrimSpace(fallbackOut) != "" {
+				logOutput = fallbackOut
+				isNewBranch = true
+			}
+		}
+	} else {
+		fallbackOut, fallbackErr := runPushSummaryGitLog(ctx, repoRoot, logFormat, "refs/heads/"+branchName)
+		if fallbackErr == nil {
+			logOutput = fallbackOut
+			isNewBranch = strings.TrimSpace(logOutput) != ""
+		}
+	}
+	if strings.TrimSpace(logOutput) == "" {
+		return
+	}
+
+	summaries := parsePushSummaryFromLog(logOutput)
+	if len(summaries) == 0 {
+		return
+	}
+
+	totalCommits := len(strings.Split(strings.TrimSpace(logOutput), "\n"))
+	lines := formatSessionTree(summaries, formatSessionTreeOpts{
+		TotalCommits: totalCommits,
+		IsNewBranch:  isNewBranch,
+	})
+	w := pushProgressOutput()
+	for _, line := range lines {
+		fmt.Fprintln(w, line)
+	}
+}
+
+func runPushSummaryGitLog(ctx context.Context, repoRoot, format, rangeSpec string) (string, error) {
+	cmd := exec.CommandContext(ctx, "git", "log", "--format="+format, rangeSpec)
+	cmd.Dir = repoRoot
+	out, err := cmd.Output()
+	if err != nil {
+		return "", fmt.Errorf("git log: %w", err)
+	}
+	return string(out), nil
+}

cmd/entire/cli/strategy/manual_commit_push_test.go

@@ -5,8 +5,11 @@ import (
 	"os/exec"
 	"testing"
 
+	"github.com/entireio/cli/cmd/entire/cli/paths"
 	"github.com/entireio/cli/cmd/entire/cli/testutil"
 
+	git "github.com/go-git/go-git/v6"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -54,3 +57,38 @@ func TestDeferCheckpointPushOnEmptyRemote_UsesLocalTrackingRefs(t *testing.T) {
 		deferCheckpointPushOnEmptyRemote(ctx, pushSettings{remote: "origin", checkpointURL: "https://example.invalid/cp.git"}),
 		"a dedicated checkpoint remote is exempt from the guard")
 }
+
+// TestFlushCheckpointRefsQueue_NonTTY_NoProgressOutput verifies the git-refs
+// default pre-push path stays silent on a non-TTY writer while still landing
+// the queued refs. captureStderr's os.Pipe write end is never a terminal, so
+// interactive.IsTerminalWriter(os.Stderr) is false for the duration of the
+// call without any extra faking.
+//
+// Not parallel: uses captureStderr's os.Stderr redirection and t.Chdir.
+func TestFlushCheckpointRefsQueue_NonTTY_NoProgressOutput(t *testing.T) {
+	workDir, bareDir, refs := setupRepoWithCheckpointRefs(t)
+	t.Chdir(workDir)
+	paths.ClearWorktreeRootCache()
+
+	repo, err := git.PlainOpen(workDir)
+	require.NoError(t, err)
+	queue := enqueueRefs(t, repo, refs)
+
+	restore := captureStderr(t)
+	pushed, pushDisabled, err := PushQueuedCheckpointRefs(context.Background(), repo, bareDir)
+	output := restore()
+
+	require.NoError(t, err)
+	assert.False(t, pushDisabled)
+	assert.Equal(t, len(refs), pushed)
+
+	assert.NotContains(t, output, "[entire] Pushing", "non-TTY stderr must contain no progress banner")
+	assert.NotContains(t, output, "syncing", "non-TTY stderr must contain no progress text")
+
+	for _, ref := range refs {
+		assert.NotEmpty(t, remoteRefHash(t, bareDir, ref), "ref should still land on the remote")
+	}
+	remaining, err := queue.Drain()
+	require.NoError(t, err)
+	assert.Empty(t, remaining, "pushed refs are removed from the queue")
+}

cmd/entire/cli/strategy/metadata_reconcile.go

@@ -194,7 +194,7 @@ func ReconcileDisconnectedMetadataRef(
 
 	fmt.Fprintf(w, "[entire] Cherry-picking %d local checkpoint(s) onto remote...\n", len(dataCommits))
 
-	newTip, err := cherryPickOnto(ctx, repo, remoteHash, dataCommits, shallow)
+	newTip, err := cherryPickOnto(ctx, repo, remoteHash, dataCommits, shallow, nil)
 	if err != nil {
 		return fmt.Errorf("failed to cherry-pick local commits onto remote: %w", err)
 	}
@@ -305,6 +305,9 @@ func loadShallowHashes(ctx context.Context, repoPath string) (map[plumbing.Hash]
 	return set, nil
 }
 
+// cherryPickProgress reports cherry-pick replay progress (current/total commits).
+type cherryPickProgress func(current, total int)
+
 // cherryPickOnto applies each commit's delta onto base, building a linear chain.
 // For each commit, it computes the full diff from its parent (additions, modifications,
 // and deletions), then applies that delta onto the current tip's tree.
@@ -314,8 +317,9 @@ func loadShallowHashes(ctx context.Context, repoPath string) (map[plumbing.Hash]
 // a shallow-boundary commit would be diffed against a stale parent tree whose
 // objects live in the local pack but no longer represent the actual checkpoint
 // history — producing nonsense changes when replayed onto the remote tip.
-func cherryPickOnto(ctx context.Context, repo *git.Repository, base plumbing.Hash, commits []*object.Commit, shallow map[plumbing.Hash]bool) (plumbing.Hash, error) {
+func cherryPickOnto(ctx context.Context, repo *git.Repository, base plumbing.Hash, commits []*object.Commit, shallow map[plumbing.Hash]bool, onProgress cherryPickProgress) (plumbing.Hash, error) {
 	currentTip := base
+	processed := 0
 
 	for _, commit := range commits {
 		changes, err := treeChangesForCherryPick(ctx, repo, commit, shallow)
@@ -343,6 +347,10 @@ func cherryPickOnto(ctx context.Context, repo *git.Repository, base plumbing.Has
 		}
 
 		currentTip = newHash
+		processed++
+		if onProgress != nil {
+			onProgress(processed, len(commits))
+		}
 	}
 
 	return currentTip, nil