feat(enable): show live progress while importing existing sessions

First-run 'entire enable' could sit silent for the whole session
import (an hour on a large corpus) between the setup summary and the
final Imported line. Wire the agentimport Progress reporter into
user-visible output via one shared helper:

- interactive terminals get the standard spinner, extended with an
  updatable message (startUpdatableSpinner; startSpinner now delegates
  to it) tracking 'session i/N - turn j/M' live
- non-TTY and ACCESSIBLE runs get one plain ANSI-free line per session,
  keeping output complete for agents and screen readers
- the standalone 'entire import <agent>' command gets the same wiring

The final summary line is unchanged, and the spinner stops before any
error path prints.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Entire-Checkpoint: 01KY93WZV7TJ0P4CSY40NYGZ1Q

Author: ecgang

cmd/entire/cli/import_cmd.go

@@ -80,11 +80,14 @@ fails even with --dry-run.`, imp.AgentType()),
 			linkCommitSHA := resolveImportLinkCommitSHA(repo)
 			logging.Debug(ctx, "import: resolved link commit", "commit_sha", linkCommitSHA)
 
+			progress, stopProgress := newImportProgressReporter(c.OutOrStdout(), string(imp.AgentType()))
 			res, err := agentimport.Run(ctx, repo, imp, agentimport.Options{
 				RepoRoot: repoRoot, OverridePath: pathFlag, SessionFilter: sessions,
 				Now: time.Now(), DryRun: dryRun,
 				LinkCommitSHA: linkCommitSHA,
+				Progress:      progress,
 			})
+			stopProgress(err == nil)
 			if err != nil {
 				return fmt.Errorf("import %s: %w", imp.Name(), err)
 			}

cmd/entire/cli/import_progress.go

@@ -0,0 +1,46 @@
+package cli
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/entireio/cli/cmd/entire/cli/agentimport"
+	"github.com/entireio/cli/cmd/entire/cli/interactive"
+)
+
+// newImportProgressReporter wires an agentimport.Progress to user-visible
+// output on w for one agent's import run. On an interactive terminal
+// (outside ACCESSIBLE mode) it drives an updatable spinner whose message
+// tracks "Importing <agentName> sessions... (session i/N · turn j/M)";
+// callers must call the returned stop exactly once when the run finishes —
+// on both the success and error paths — so no spinner frame is left
+// dangling to corrupt whatever prints next. Otherwise (non-TTY, piped, or
+// ACCESSIBLE mode) it prints one plain, ANSI-free line per session from
+// SessionStart, and stop is a no-op.
+func newImportProgressReporter(w io.Writer, agentName string) (progress *agentimport.Progress, stop func(success bool)) {
+	if !interactive.IsTerminalWriter(w) || IsAccessibleMode() {
+		return &agentimport.Progress{
+			SessionStart: func(sessionIndex, sessionTotal int, _, _ string, turnCount int) {
+				fmt.Fprintf(w, "Importing %s session %d/%d (%d %s)...\n",
+					agentName, sessionIndex+1, sessionTotal, turnCount, pluralize("turn", turnCount))
+			},
+		}, func(bool) {}
+	}
+
+	update, spinnerStop := startUpdatableSpinner(w, fmt.Sprintf("Importing %s sessions...", agentName))
+	var curSession, curSessionTotal, curTurnTotal int
+	render := func(turnsDone int) {
+		update(fmt.Sprintf("Importing %s sessions... (session %d/%d · turn %d/%d)",
+			agentName, curSession, curSessionTotal, turnsDone, curTurnTotal))
+	}
+	progress = &agentimport.Progress{
+		SessionStart: func(sessionIndex, sessionTotal int, _, _ string, turnCount int) {
+			curSession, curSessionTotal, curTurnTotal = sessionIndex+1, sessionTotal, turnCount
+			render(0)
+		},
+		TurnWritten: func(_, turnIndex, _ int) {
+			render(turnIndex + 1)
+		},
+	}
+	return progress, spinnerStop
+}

cmd/entire/cli/progress.go

@@ -3,6 +3,7 @@ package cli
 import (
 	"fmt"
 	"io"
+	"sync"
 	"time"
 
 	"github.com/entireio/cli/cmd/entire/cli/interactive"
@@ -26,10 +27,35 @@ const (
 // On non-terminal writers the animation is omitted but stop(true) still
 // prints the completion line.
 func startSpinner(w io.Writer, msg string) func(success bool) {
+	_, stop := startUpdatableSpinner(w, msg)
+	return stop
+}
+
+// startUpdatableSpinner is startSpinner's variant for an operation whose
+// status text changes while it runs (e.g. "session 2/5 · turn 3/10"). update
+// replaces the message the next frame draws — or, on a non-terminal writer,
+// the message stop's completion line uses. update is safe to call at any
+// point, including before the spinner's first frame draws and after stop
+// returns. stop behaves exactly like startSpinner's, rendering whichever
+// message update last set (or msg, if update was never called).
+func startUpdatableSpinner(w io.Writer, msg string) (update func(string), stop func(success bool)) {
+	var mu sync.Mutex
+	current := msg
+	setMsg := func(m string) {
+		mu.Lock()
+		current = m
+		mu.Unlock()
+	}
+	getMsg := func() string {
+		mu.Lock()
+		defer mu.Unlock()
+		return current
+	}
+
 	if !interactive.IsTerminalWriter(w) {
-		return func(success bool) {
+		return setMsg, func(success bool) {
 			if success {
-				fmt.Fprintf(w, "✓ %s\n", msg)
+				fmt.Fprintf(w, "✓ %s\n", getMsg())
 			}
 		}
 	}
@@ -46,23 +72,27 @@ func startSpinner(w io.Writer, msg string) func(success bool) {
 		ticker := time.NewTicker(spinnerInterval)
 		defer ticker.Stop()
 		frame := 0
-		fmt.Fprintf(w, "\r%s %s", spinnerFrames[frame], msg)
-		frame = (frame + 1) % len(spinnerFrames)
+		draw := func() {
+			// \033[K clears the rest of the line so a shorter message
+			// (update shrank it) doesn't leave stale trailing characters.
+			fmt.Fprintf(w, "\r\033[K%s %s", spinnerFrames[frame], getMsg())
+			frame = (frame + 1) % len(spinnerFrames)
+		}
+		draw()
 		for {
 			select {
 			case <-done:
 				return
 			case <-ticker.C:
-				fmt.Fprintf(w, "\r%s %s", spinnerFrames[frame], msg)
-				frame = (frame + 1) % len(spinnerFrames)
+				draw()
 			}
 		}
 	}()
-	return func(success bool) {
+	return setMsg, func(success bool) {
 		close(done)
 		<-stopped
 		if success {
-			fmt.Fprintf(w, "\r\033[K✓ %s\n", msg)
+			fmt.Fprintf(w, "\r\033[K✓ %s\n", getMsg())
 			return
 		}
 		fmt.Fprint(w, "\r\033[K")

cmd/entire/cli/progress_test.go

@@ -0,0 +1,77 @@
+package cli
+
+import (
+	"bytes"
+	"testing"
+)
+
+// TestStartSpinner_NonTTYFallback locks in startSpinner's non-terminal
+// contract now that it delegates to startUpdatableSpinner: no animation, and
+// stop(true)/stop(false) behave exactly as they did before the refactor.
+func TestStartSpinner_NonTTYFallback(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name    string
+		success bool
+		want    string
+	}{
+		{name: "success prints completion line", success: true, want: "✓ doing work\n"},
+		{name: "failure prints nothing", success: false, want: ""},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			var buf bytes.Buffer
+			stop := startSpinner(&buf, "doing work")
+			stop(tt.success)
+			if got := buf.String(); got != tt.want {
+				t.Errorf("stop(%v) = %q, want %q", tt.success, got, tt.want)
+			}
+		})
+	}
+}
+
+// TestStartUpdatableSpinner_NonTTYUpdateBeforeAnyDraw proves update is safe to
+// call before anything has been drawn (a non-terminal writer never draws an
+// in-flight frame at all, so every call here is "before the first draw") and
+// that stop renders whichever message was set last.
+func TestStartUpdatableSpinner_NonTTYUpdateBeforeAnyDraw(t *testing.T) {
+	t.Parallel()
+	var buf bytes.Buffer
+	update, stop := startUpdatableSpinner(&buf, "starting")
+	update("session 1/2 · turn 1/2")
+	update("session 2/2 · turn 2/2")
+	stop(true)
+	if got, want := buf.String(), "✓ session 2/2 · turn 2/2\n"; got != want {
+		t.Errorf("stop(true) after updates = %q, want %q", got, want)
+	}
+}
+
+// TestStartUpdatableSpinner_NonTTYStopFalseIgnoresUpdates proves a failed run
+// leaves no trace, regardless of how many updates preceded it.
+func TestStartUpdatableSpinner_NonTTYStopFalseIgnoresUpdates(t *testing.T) {
+	t.Parallel()
+	var buf bytes.Buffer
+	update, stop := startUpdatableSpinner(&buf, "starting")
+	update("mid-flight")
+	stop(false)
+	if got := buf.String(); got != "" {
+		t.Errorf("stop(false) = %q, want empty (no dangling output)", got)
+	}
+}
+
+// TestStartUpdatableSpinner_NonTTYStopDoesNotPanicOnRepeatCalls documents the
+// non-terminal stop closure's existing idempotency: it never closes a
+// channel (that only happens on the terminal path), so calling it again is
+// safe — it just re-prints the completion line. This matches startSpinner's
+// pre-existing non-TTY behavior; the terminal path remains single-call only.
+func TestStartUpdatableSpinner_NonTTYStopDoesNotPanicOnRepeatCalls(t *testing.T) {
+	t.Parallel()
+	var buf bytes.Buffer
+	_, stop := startUpdatableSpinner(&buf, "starting")
+	stop(true)
+	stop(true)
+	if got, want := buf.String(), "✓ starting\n✓ starting\n"; got != want {
+		t.Errorf("double stop(true) = %q, want %q", got, want)
+	}
+}

cmd/entire/cli/setup_import.go

@@ -223,10 +223,13 @@ func runSelectedImports(ctx context.Context, w io.Writer, repoRoot string, selec
 
 	var importedLocalHistory bool
 	for _, e := range selected {
+		progress, stopProgress := newImportProgressReporter(w, e.displayName)
 		res, err := agentimport.Run(ctx, repo, e.imp, agentimport.Options{
 			RepoRoot: repoRoot,
 			Now:      time.Now(),
+			Progress: progress,
 		})
+		stopProgress(err == nil)
 		if err != nil {
 			logging.Warn(ctx, "session import failed", "agent", e.imp.Name(), "error", err)
 			fmt.Fprintf(w, "Note: could not import %s history: %v\n", e.displayName, err)

cmd/entire/cli/setup_import_test.go

@@ -4,9 +4,11 @@ import (
 	"bytes"
 	"context"
 	"errors"
+	"fmt"
 	"io"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/entireio/cli/cmd/entire/cli/agent"
 	"github.com/entireio/cli/cmd/entire/cli/agent/types"
@@ -282,3 +284,94 @@ func TestMaybeOfferSessionImport_PromptErrorIsBestEffort(t *testing.T) {
 		t.Error("import ran after a prompt error; expected skip")
 	}
 }
+
+// fixedDiscoverImporter wraps a real agentimport.Importer but overrides
+// Discover to return a fixed, caller-supplied set of session files instead of
+// scanning the agent's real transcript directory. runSelectedImports (unlike
+// the standalone `entire import` command) has no --path flag to redirect
+// discovery, so this is the seam tests use to feed it a fixture.
+type fixedDiscoverImporter struct {
+	agentimport.Importer
+
+	sessions []agentimport.SessionFile
+}
+
+func (f fixedDiscoverImporter) Discover(string, string, time.Time, []string) ([]agentimport.SessionFile, error) {
+	return f.sessions, nil
+}
+
+// writeImportProgressFixtureSession writes a 2-turn Claude Code transcript
+// fixture, matching the format agentimport's claude importer parses.
+func writeImportProgressFixtureSession(t *testing.T, dir, name string) {
+	t.Helper()
+	content := strings.Join([]string{
+		`{"type":"user","uuid":"u1","timestamp":"2026-06-20T00:00:00Z","message":{"role":"user","content":"first"}}`,
+		`{"type":"assistant","uuid":"a1","message":{"id":"m1","model":"claude-x","content":[{"type":"text","text":"ok"}],"usage":{"output_tokens":5}}}`,
+		`{"type":"user","uuid":"u2","timestamp":"2026-06-20T00:01:00Z","message":{"role":"user","content":"second"}}`,
+	}, "\n") + "\n"
+	testutil.WriteFile(t, dir, name, content)
+}
+
+// TestRunSelectedImports_NonTTYProgressLines proves the wired-in progress
+// reporter, running against a plain (non-terminal) writer, prints exactly one
+// plain line per session — carrying the agent name, its position, and its
+// turn count — writes no ANSI escapes, and leaves the pre-existing final
+// summary line unchanged.
+func TestRunSelectedImports_NonTTYProgressLines(t *testing.T) {
+	// Not parallel: chdirs into a temp repo and performs real checkpoint writes.
+	dir := t.TempDir()
+	testutil.InitRepo(t, dir)
+	testutil.WriteFile(t, dir, "f.txt", "x")
+	testutil.GitAdd(t, dir, "f.txt")
+	testutil.GitCommit(t, dir, "init")
+	t.Chdir(dir)
+	ctx := context.Background()
+
+	sessionsDir := t.TempDir()
+	writeImportProgressFixtureSession(t, sessionsDir, "sess1.jsonl")
+	writeImportProgressFixtureSession(t, sessionsDir, "sess2.jsonl")
+
+	var claudeImp agentimport.Importer
+	for _, imp := range agentimport.All() {
+		if imp.Name() == testAgentName {
+			claudeImp = imp
+		}
+	}
+	if claudeImp == nil {
+		t.Fatal("claude-code importer not registered")
+	}
+	sessions, err := claudeImp.Discover(dir, sessionsDir, time.Now(), nil)
+	if err != nil {
+		t.Fatalf("discover fixture sessions: %v", err)
+	}
+	if len(sessions) != 2 {
+		t.Fatalf("want 2 fixture sessions, got %d", len(sessions))
+	}
+	imp := fixedDiscoverImporter{Importer: claudeImp, sessions: sessions}
+	agentName := string(claudeImp.AgentType())
+
+	var buf bytes.Buffer
+	runSelectedImports(ctx, &buf, dir, []eligibleImport{{imp: imp, displayName: agentName}})
+	out := buf.String()
+
+	if strings.ContainsRune(out, '\x1b') {
+		t.Fatalf("output contains an ESC byte on a non-TTY writer: %q", out)
+	}
+
+	wantLines := []string{
+		fmt.Sprintf("Importing %s session 1/2 (2 turns)...", agentName),
+		fmt.Sprintf("Importing %s session 2/2 (2 turns)...", agentName),
+	}
+	for _, line := range wantLines {
+		if !strings.Contains(out, line) {
+			t.Errorf("missing progress line %q in output:\n%s", line, out)
+		}
+	}
+	if got := strings.Count(out, fmt.Sprintf("Importing %s session", agentName)); got != 2 {
+		t.Errorf("got %d progress lines, want exactly 2 (one per session):\n%s", got, out)
+	}
+
+	if want := "Imported 4 turn(s) from 2 session(s) (0 already imported).\n"; !strings.Contains(out, want) {
+		t.Errorf("final summary line missing or changed; want %q in:\n%s", want, out)
+	}
+}