fix(repo): keep repo list table colored under the pager

flushThroughPager renders into a buffer that never looks like a TTY, so
printTable's writer-based color gate switched repo list to plain output
on interactive terminals. Pre-style headers/cells against the real
writer before the swap (as the mirror list view already does).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Entire-Checkpoint: 01KY7BSJFSJB67P46XPVH3XG43

Author: gtrrz-victor

cmd/entire/cli/corecmd.go

@@ -433,6 +433,43 @@ func printTable[T any](w io.Writer, headers []string, items []T, row func(T) []s
 	return nil
 }
 
+// preStyleTable pre-colors table headers and a row function against w's color
+// capability, so a command that renders its table into a pager buffer keeps
+// its color. printTable/renderCoreListPage decide color from the writer they
+// render into; under flushThroughPager that writer is an in-memory buffer,
+// which never looks like a TTY, so a straight render there is always plain.
+// Pre-styling against the real output writer here and letting the buffered
+// render pass the ANSI through unchanged (its own color gate is off, so it
+// never re-styles) restores it — the same approach the mirror-list view takes.
+// Identity (no wrapping) when color is off, so pipes, tests, and NO_COLOR see
+// bare text byte for byte.
+func preStyleTable[T any](w io.Writer, headers []string, row func(T) []string) ([]string, func(T) []string) {
+	return styleTableWith(newTableStyles(w), headers, row)
+}
+
+// styleTableWith is the pure core of preStyleTable: it applies st's header and
+// per-column styles to the headers and row cells, matching how printTable
+// colors a direct render. Split out from the writer-facing wrapper so the
+// enabled path is unit-testable without a real terminal. Identity when st is
+// disabled, so plain output stays byte-for-byte unchanged.
+func styleTableWith[T any](st tableStyles, headers []string, row func(T) []string) ([]string, func(T) []string) {
+	if !st.enabled {
+		return headers, row
+	}
+	styledHeaders := make([]string, len(headers))
+	for i, h := range headers {
+		styledHeaders[i] = st.style(st.header, h)
+	}
+	styledRow := func(t T) []string {
+		cells := row(t)
+		for i := range cells {
+			cells[i] = st.style(st.columnStyle(i), cells[i])
+		}
+		return cells
+	}
+	return styledHeaders, styledRow
+}
+
 // printFields writes a single record as aligned "FIELD  value" lines: the
 // label in header gray, the value in the same primary/secondary color the
 // list view would give that column.

cmd/entire/cli/corecmd_test.go

@@ -8,6 +8,7 @@ import (
 	"strings"
 	"testing"
 
+	"charm.land/lipgloss/v2"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/require"
 )
@@ -206,6 +207,43 @@ func TestPageModeRequested(t *testing.T) {
 	require.True(t, mode("--page-token", ""), "an explicit empty cursor still selects page mode")
 }
 
+// TestStyleTableWith covers the pre-styling that keeps a paged list command's
+// table colored: the render inside flushThroughPager targets a buffer that
+// never looks like a TTY, so color is decided against the real writer up front
+// and applied here. The enabled path must color the header row and route each
+// data cell through its column style (first column primary, rest secondary);
+// the disabled path must be an exact identity so pipes, tests, and NO_COLOR
+// see bare text byte for byte.
+func TestStyleTableWith(t *testing.T) {
+	t.Parallel()
+
+	headers := []string{"ID", "NAME"}
+	row := func(r []string) []string { return r }
+	item := []string{"a", "b"}
+
+	t.Run("enabled path colors headers and routes cells by column", func(t *testing.T) {
+		t.Parallel()
+		st := tableStyles{
+			enabled: true,
+			header:  lipgloss.NewStyle().Bold(true),
+			primary: lipgloss.NewStyle().Underline(true),
+			cell:    lipgloss.NewStyle().Faint(true),
+		}
+		gotHeaders, gotRow := styleTableWith(st, headers, row)
+		require.Equal(t, []string{st.header.Render("ID"), st.header.Render("NAME")}, gotHeaders)
+		// Column 0 is the primary identifier, the rest secondary — the same
+		// split printTable applies when it colors a direct render.
+		require.Equal(t, []string{st.primary.Render("a"), st.cell.Render("b")}, gotRow(item))
+	})
+
+	t.Run("disabled path is an exact identity", func(t *testing.T) {
+		t.Parallel()
+		gotHeaders, gotRow := styleTableWith(tableStyles{}, headers, row)
+		require.Equal(t, headers, gotHeaders)
+		require.Equal(t, item, gotRow(item))
+	})
+}
+
 // printTable/printFields render plain (no color/escape) when the writer
 // isn't a TTY — which a bytes.Buffer never is — so these assert the plain
 // layout directly.

cmd/entire/cli/repo.go

@@ -175,6 +175,11 @@ func newRepoListCmd() *cobra.Command {
 			return validatePageSize(cmd, pageSize)
 		},
 		RunE: func(cmd *cobra.Command, args []string) error {
+			// Decide color against the real output writer before
+			// flushThroughPager swaps stdout for a buffer that never looks
+			// like a TTY; the buffered render passes the pre-styled cells
+			// through unchanged (see preStyleTable).
+			headers, row := preStyleTable(cmd.OutOrStdout(), repoColumns, repoRow)
 			if pageModeRequested(cmd) {
 				return flushThroughPager(cmd, noPager, func() error {
 					return runCore(cmd, func(ctx context.Context, c *coreapi.Client) error {
@@ -193,12 +198,12 @@ func newRepoListCmd() *cobra.Command {
 						if err != nil {
 							return err
 						}
-						return renderCoreListPage(cmd, "No repositories found in this project.", repoColumns, repoRow, out.Repos, out.NextPageToken.Or(""))
+						return renderCoreListPage(cmd, "No repositories found in this project.", headers, row, out.Repos, out.NextPageToken.Or(""))
 					})
 				})
 			}
 			return flushThroughPager(cmd, noPager, func() error {
-				return runCoreList(cmd, "No repositories found in this project.", repoColumns, repoRow, func(ctx context.Context, c *coreapi.Client) ([]coreapi.Repo, error) {
+				return runCoreList(cmd, "No repositories found in this project.", headers, row, func(ctx context.Context, c *coreapi.Client) ([]coreapi.Repo, error) {
 					projID, err := resolveProjectRef(ctx, c, args[0])
 					if err != nil {
 						return nil, err