chore: remove usage tracking and logging functionality

- Deleted the `LoggerPlugin` along with associated usage tracking and in-memory statistics logic.
- Removed all related tests (`logger_plugin_test.go`, `usage_tab_test.go`) and external-facing handler (`usage.go`) for usage statistics export/import.
- Cleaned up TUI integration by deleting `usage_tab.go`.

internal/tui/app.go

@@ -18,7 +18,6 @@ const (
 	tabAuthFiles
 	tabAPIKeys
 	tabOAuth
-	tabUsage
 	tabLogs
 )
 
@@ -40,7 +39,6 @@ type App struct {
 	auth      authTabModel
 	keys      keysTabModel
 	oauth     oauthTabModel
-	usage     usageTabModel
 	logs      logsTabModel
 
 	client *Client
@@ -50,7 +48,7 @@ type App struct {
 	ready  bool
 
 	// Track which tabs have been initialized (fetched data)
-	initialized [7]bool
+	initialized [6]bool
 }
 
 type authConnectMsg struct {
@@ -81,10 +79,9 @@ func NewApp(port int, secretKey string, hook *LogHook) App {
 		auth:          newAuthTabModel(client),
 		keys:          newKeysTabModel(client),
 		oauth:         newOAuthTabModel(client),
-		usage:         newUsageTabModel(client),
 		logs:          newLogsTabModel(client, hook),
 		client:        client,
-		initialized: [7]bool{
+		initialized: [6]bool{
 			tabDashboard: true,
 			tabLogs:      true,
 		},
@@ -92,7 +89,7 @@ func NewApp(port int, secretKey string, hook *LogHook) App {
 
 	app.refreshTabs()
 	if authRequired {
-		app.initialized = [7]bool{}
+		app.initialized = [6]bool{}
 	}
 	app.setAuthInputPrompt()
 	return app
@@ -128,7 +125,6 @@ func (a App) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		a.auth.SetSize(contentW, contentH)
 		a.keys.SetSize(contentW, contentH)
 		a.oauth.SetSize(contentW, contentH)
-		a.usage.SetSize(contentW, contentH)
 		a.logs.SetSize(contentW, contentH)
 		return a, nil
 
@@ -142,7 +138,7 @@ func (a App) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		a.authenticated = true
 		a.logsEnabled = a.standalone || isLogsEnabledFromConfig(msg.cfg)
 		a.refreshTabs()
-		a.initialized = [7]bool{}
+		a.initialized = [6]bool{}
 		a.initialized[tabDashboard] = true
 		cmds := []tea.Cmd{a.dashboard.Init()}
 		if a.logsEnabled {
@@ -258,8 +254,6 @@ func (a App) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		a.keys, cmd = a.keys.Update(msg)
 	case tabOAuth:
 		a.oauth, cmd = a.oauth.Update(msg)
-	case tabUsage:
-		a.usage, cmd = a.usage.Update(msg)
 	case tabLogs:
 		a.logs, cmd = a.logs.Update(msg)
 	}
@@ -322,8 +316,6 @@ func (a *App) initTabIfNeeded(_ int) tea.Cmd {
 		return a.keys.Init()
 	case tabOAuth:
 		return a.oauth.Init()
-	case tabUsage:
-		return a.usage.Init()
 	case tabLogs:
 		if !a.logsEnabled {
 			return nil
@@ -360,8 +352,6 @@ func (a App) View() string {
 		sb.WriteString(a.keys.View())
 	case tabOAuth:
 		sb.WriteString(a.oauth.View())
-	case tabUsage:
-		sb.WriteString(a.usage.View())
 	case tabLogs:
 		if a.logsEnabled {
 			sb.WriteString(a.logs.View())
@@ -529,10 +519,6 @@ func (a App) broadcastToAllTabs(msg tea.Msg) (tea.Model, tea.Cmd) {
 	if cmd != nil {
 		cmds = append(cmds, cmd)
 	}
-	a.usage, cmd = a.usage.Update(msg)
-	if cmd != nil {
-		cmds = append(cmds, cmd)
-	}
 	a.logs, cmd = a.logs.Update(msg)
 	if cmd != nil {
 		cmds = append(cmds, cmd)

internal/tui/client.go

@@ -140,11 +140,6 @@ func (c *Client) PutConfigYAML(yamlContent string) error {
 	return err
 }
 
-// GetUsage fetches usage statistics.
-func (c *Client) GetUsage() (map[string]any, error) {
-	return c.getJSON("/v0/management/usage")
-}
-
 // GetAuthFiles lists auth credential files.
 // API returns {"files": [...]}.
 func (c *Client) GetAuthFiles() ([]map[string]any, error) {

internal/tui/dashboard.go

@@ -22,14 +22,12 @@ type dashboardModel struct {
 
 	// Cached data for re-rendering on locale change
 	lastConfig    map[string]any
-	lastUsage     map[string]any
 	lastAuthFiles []map[string]any
 	lastAPIKeys   []string
 }
 
 type dashboardDataMsg struct {
 	config    map[string]any
-	usage     map[string]any
 	authFiles []map[string]any
 	apiKeys   []string
 	err       error
@@ -47,25 +45,24 @@ func (m dashboardModel) Init() tea.Cmd {
 
 func (m dashboardModel) fetchData() tea.Msg {
 	cfg, cfgErr := m.client.GetConfig()
-	usage, usageErr := m.client.GetUsage()
 	authFiles, authErr := m.client.GetAuthFiles()
 	apiKeys, keysErr := m.client.GetAPIKeys()
 
 	var err error
-	for _, e := range []error{cfgErr, usageErr, authErr, keysErr} {
+	for _, e := range []error{cfgErr, authErr, keysErr} {
 		if e != nil {
 			err = e
 			break
 		}
 	}
-	return dashboardDataMsg{config: cfg, usage: usage, authFiles: authFiles, apiKeys: apiKeys, err: err}
+	return dashboardDataMsg{config: cfg, authFiles: authFiles, apiKeys: apiKeys, err: err}
 }
 
 func (m dashboardModel) Update(msg tea.Msg) (dashboardModel, tea.Cmd) {
 	switch msg := msg.(type) {
 	case localeChangedMsg:
 		// Re-render immediately with cached data using new locale
-		m.content = m.renderDashboard(m.lastConfig, m.lastUsage, m.lastAuthFiles, m.lastAPIKeys)
+		m.content = m.renderDashboard(m.lastConfig, m.lastAuthFiles, m.lastAPIKeys)
 		m.viewport.SetContent(m.content)
 		// Also fetch fresh data in background
 		return m, m.fetchData
@@ -78,11 +75,10 @@ func (m dashboardModel) Update(msg tea.Msg) (dashboardModel, tea.Cmd) {
 			m.err = nil
 			// Cache data for locale switching
 			m.lastConfig = msg.config
-			m.lastUsage = msg.usage
 			m.lastAuthFiles = msg.authFiles
 			m.lastAPIKeys = msg.apiKeys
 
-			m.content = m.renderDashboard(msg.config, msg.usage, msg.authFiles, msg.apiKeys)
+			m.content = m.renderDashboard(msg.config, msg.authFiles, msg.apiKeys)
 		}
 		m.viewport.SetContent(m.content)
 		return m, nil
@@ -121,7 +117,7 @@ func (m dashboardModel) View() string {
 	return m.viewport.View()
 }
 
-func (m dashboardModel) renderDashboard(cfg, usage map[string]any, authFiles []map[string]any, apiKeys []string) string {
+func (m dashboardModel) renderDashboard(cfg map[string]any, authFiles []map[string]any, apiKeys []string) string {
 	var sb strings.Builder
 
 	sb.WriteString(titleStyle.Render(T("dashboard_title")))
@@ -138,7 +134,7 @@ func (m dashboardModel) renderDashboard(cfg, usage map[string]any, authFiles []m
 	// ━━━ Stats Cards ━━━
 	cardWidth := 25
 	if m.width > 0 {
-		cardWidth = (m.width - 6) / 4
+		cardWidth = (m.width - 2) / 2
 		if cardWidth < 18 {
 			cardWidth = 18
 		}
@@ -173,34 +169,7 @@ func (m dashboardModel) renderDashboard(cfg, usage map[string]any, authFiles []m
 		lipgloss.NewStyle().Foreground(colorMuted).Render(fmt.Sprintf("%s (%d %s)", T("auth_files_label"), activeAuth, T("active_suffix"))),
 	))
 
-	// Card 3: Total Requests
-	totalReqs := int64(0)
-	successReqs := int64(0)
-	failedReqs := int64(0)
-	totalTokens := int64(0)
-	if usage != nil {
-		if usageMap, ok := usage["usage"].(map[string]any); ok {
-			totalReqs = int64(getFloat(usageMap, "total_requests"))
-			successReqs = int64(getFloat(usageMap, "success_count"))
-			failedReqs = int64(getFloat(usageMap, "failure_count"))
-			totalTokens = int64(getFloat(usageMap, "total_tokens"))
-		}
-	}
-	card3 := cardStyle.Render(fmt.Sprintf(
-		"%s\n%s",
-		lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("214")).Render(fmt.Sprintf("📈 %d", totalReqs)),
-		lipgloss.NewStyle().Foreground(colorMuted).Render(fmt.Sprintf("%s (✓%d ✗%d)", T("total_requests"), successReqs, failedReqs)),
-	))
-
-	// Card 4: Total Tokens
-	tokenStr := formatLargeNumber(totalTokens)
-	card4 := cardStyle.Render(fmt.Sprintf(
-		"%s\n%s",
-		lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("170")).Render(fmt.Sprintf("🔤 %s", tokenStr)),
-		lipgloss.NewStyle().Foreground(colorMuted).Render(T("total_tokens")),
-	))
-
-	sb.WriteString(lipgloss.JoinHorizontal(lipgloss.Top, card1, " ", card2, " ", card3, " ", card4))
+	sb.WriteString(lipgloss.JoinHorizontal(lipgloss.Top, card1, " ", card2))
 	sb.WriteString("\n\n")
 
 	// ━━━ Current Config ━━━
@@ -258,38 +227,6 @@ func (m dashboardModel) renderDashboard(cfg, usage map[string]any, authFiles []m
 
 	sb.WriteString("\n")
 
-	// ━━━ Per-Model Usage ━━━
-	if usage != nil {
-		if usageMap, ok := usage["usage"].(map[string]any); ok {
-			if apis, ok := usageMap["apis"].(map[string]any); ok && len(apis) > 0 {
-				sb.WriteString(lipgloss.NewStyle().Bold(true).Foreground(colorHighlight).Render(T("model_stats")))
-				sb.WriteString("\n")
-				sb.WriteString(strings.Repeat("─", minInt(m.width, 60)))
-				sb.WriteString("\n")
-
-				header := fmt.Sprintf("  %-40s %10s %12s", T("model"), T("requests"), T("tokens"))
-				sb.WriteString(tableHeaderStyle.Render(header))
-				sb.WriteString("\n")
-
-				for _, apiSnap := range apis {
-					if apiMap, ok := apiSnap.(map[string]any); ok {
-						if models, ok := apiMap["models"].(map[string]any); ok {
-							for model, v := range models {
-								if stats, ok := v.(map[string]any); ok {
-									reqs := int64(getFloat(stats, "total_requests"))
-									toks := int64(getFloat(stats, "total_tokens"))
-									row := fmt.Sprintf("  %-40s %10d %12s", truncate(model, 40), reqs, formatLargeNumber(toks))
-									sb.WriteString(tableCellStyle.Render(row))
-									sb.WriteString("\n")
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-
 	return sb.String()
 }
 

internal/tui/i18n.go

@@ -50,8 +50,8 @@ var locales = map[string]map[string]string{
 // ──────────────────────────────────────────
 // Tab names
 // ──────────────────────────────────────────
-var zhTabNames = []string{"仪表盘", "配置", "认证文件", "API 密钥", "OAuth", "使用统计", "日志"}
-var enTabNames = []string{"Dashboard", "Config", "Auth Files", "API Keys", "OAuth", "Usage", "Logs"}
+var zhTabNames = []string{"仪表盘", "配置", "认证文件", "API 密钥", "OAuth", "日志"}
+var enTabNames = []string{"Dashboard", "Config", "Auth Files", "API Keys", "OAuth", "Logs"}
 
 // TabNames returns tab names in the current locale.
 func TabNames() []string {

internal/tui/usage_tab.go

@@ -1,418 +0,0 @@
-package tui
-
-import (
-	"fmt"
-	"sort"
-	"strings"
-
-	"github.com/charmbracelet/bubbles/viewport"
-	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/lipgloss"
-)
-
-// usageTabModel displays usage statistics with charts and breakdowns.
-type usageTabModel struct {
-	client   *Client
-	viewport viewport.Model
-	usage    map[string]any
-	err      error
-	width    int
-	height   int
-	ready    bool
-}
-
-type usageDataMsg struct {
-	usage map[string]any
-	err   error
-}
-
-func newUsageTabModel(client *Client) usageTabModel {
-	return usageTabModel{
-		client: client,
-	}
-}
-
-func (m usageTabModel) Init() tea.Cmd {
-	return m.fetchData
-}
-
-func (m usageTabModel) fetchData() tea.Msg {
-	usage, err := m.client.GetUsage()
-	return usageDataMsg{usage: usage, err: err}
-}
-
-func (m usageTabModel) Update(msg tea.Msg) (usageTabModel, tea.Cmd) {
-	switch msg := msg.(type) {
-	case localeChangedMsg:
-		m.viewport.SetContent(m.renderContent())
-		return m, nil
-	case usageDataMsg:
-		if msg.err != nil {
-			m.err = msg.err
-		} else {
-			m.err = nil
-			m.usage = msg.usage
-		}
-		m.viewport.SetContent(m.renderContent())
-		return m, nil
-
-	case tea.KeyMsg:
-		if msg.String() == "r" {
-			return m, m.fetchData
-		}
-		var cmd tea.Cmd
-		m.viewport, cmd = m.viewport.Update(msg)
-		return m, cmd
-	}
-
-	var cmd tea.Cmd
-	m.viewport, cmd = m.viewport.Update(msg)
-	return m, cmd
-}
-
-func (m *usageTabModel) SetSize(w, h int) {
-	m.width = w
-	m.height = h
-	if !m.ready {
-		m.viewport = viewport.New(w, h)
-		m.viewport.SetContent(m.renderContent())
-		m.ready = true
-	} else {
-		m.viewport.Width = w
-		m.viewport.Height = h
-	}
-}
-
-func (m usageTabModel) View() string {
-	if !m.ready {
-		return T("loading")
-	}
-	return m.viewport.View()
-}
-
-func (m usageTabModel) renderContent() string {
-	var sb strings.Builder
-
-	sb.WriteString(titleStyle.Render(T("usage_title")))
-	sb.WriteString("\n")
-	sb.WriteString(helpStyle.Render(T("usage_help")))
-	sb.WriteString("\n\n")
-
-	if m.err != nil {
-		sb.WriteString(errorStyle.Render("⚠ Error: " + m.err.Error()))
-		sb.WriteString("\n")
-		return sb.String()
-	}
-
-	if m.usage == nil {
-		sb.WriteString(subtitleStyle.Render(T("usage_no_data")))
-		sb.WriteString("\n")
-		return sb.String()
-	}
-
-	usageMap, _ := m.usage["usage"].(map[string]any)
-	if usageMap == nil {
-		sb.WriteString(subtitleStyle.Render(T("usage_no_data")))
-		sb.WriteString("\n")
-		return sb.String()
-	}
-
-	totalReqs := int64(getFloat(usageMap, "total_requests"))
-	successCnt := int64(getFloat(usageMap, "success_count"))
-	failureCnt := int64(getFloat(usageMap, "failure_count"))
-	totalTokens := int64(getFloat(usageMap, "total_tokens"))
-
-	// ━━━ Overview Cards ━━━
-	cardWidth := 20
-	if m.width > 0 {
-		cardWidth = (m.width - 6) / 4
-		if cardWidth < 16 {
-			cardWidth = 16
-		}
-	}
-	cardStyle := lipgloss.NewStyle().
-		Border(lipgloss.RoundedBorder()).
-		BorderForeground(lipgloss.Color("240")).
-		Padding(0, 1).
-		Width(cardWidth).
-		Height(3)
-
-	// Total Requests
-	card1 := cardStyle.Copy().BorderForeground(lipgloss.Color("111")).Render(fmt.Sprintf(
-		"%s\n%s\n%s",
-		lipgloss.NewStyle().Foreground(colorMuted).Render(T("usage_total_reqs")),
-		lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("111")).Render(fmt.Sprintf("%d", totalReqs)),
-		lipgloss.NewStyle().Foreground(colorMuted).Render(fmt.Sprintf("● %s: %d  ● %s: %d", T("usage_success"), successCnt, T("usage_failure"), failureCnt)),
-	))
-
-	// Total Tokens
-	card2 := cardStyle.Copy().BorderForeground(lipgloss.Color("214")).Render(fmt.Sprintf(
-		"%s\n%s\n%s",
-		lipgloss.NewStyle().Foreground(colorMuted).Render(T("usage_total_tokens")),
-		lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("214")).Render(formatLargeNumber(totalTokens)),
-		lipgloss.NewStyle().Foreground(colorMuted).Render(fmt.Sprintf("%s: %s", T("usage_total_token_l"), formatLargeNumber(totalTokens))),
-	))
-
-	// RPM
-	rpm := float64(0)
-	if totalReqs > 0 {
-		if rByH, ok := usageMap["requests_by_hour"].(map[string]any); ok && len(rByH) > 0 {
-			rpm = float64(totalReqs) / float64(len(rByH)) / 60.0
-		}
-	}
-	card3 := cardStyle.Copy().BorderForeground(lipgloss.Color("76")).Render(fmt.Sprintf(
-		"%s\n%s\n%s",
-		lipgloss.NewStyle().Foreground(colorMuted).Render(T("usage_rpm")),
-		lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("76")).Render(fmt.Sprintf("%.2f", rpm)),
-		lipgloss.NewStyle().Foreground(colorMuted).Render(fmt.Sprintf("%s: %d", T("usage_total_reqs"), totalReqs)),
-	))
-
-	// TPM
-	tpm := float64(0)
-	if totalTokens > 0 {
-		if tByH, ok := usageMap["tokens_by_hour"].(map[string]any); ok && len(tByH) > 0 {
-			tpm = float64(totalTokens) / float64(len(tByH)) / 60.0
-		}
-	}
-	card4 := cardStyle.Copy().BorderForeground(lipgloss.Color("170")).Render(fmt.Sprintf(
-		"%s\n%s\n%s",
-		lipgloss.NewStyle().Foreground(colorMuted).Render(T("usage_tpm")),
-		lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("170")).Render(fmt.Sprintf("%.2f", tpm)),
-		lipgloss.NewStyle().Foreground(colorMuted).Render(fmt.Sprintf("%s: %s", T("usage_total_tokens"), formatLargeNumber(totalTokens))),
-	))
-
-	sb.WriteString(lipgloss.JoinHorizontal(lipgloss.Top, card1, " ", card2, " ", card3, " ", card4))
-	sb.WriteString("\n\n")
-
-	// ━━━ Requests by Hour (ASCII bar chart) ━━━
-	if rByH, ok := usageMap["requests_by_hour"].(map[string]any); ok && len(rByH) > 0 {
-		sb.WriteString(lipgloss.NewStyle().Bold(true).Foreground(colorHighlight).Render(T("usage_req_by_hour")))
-		sb.WriteString("\n")
-		sb.WriteString(strings.Repeat("─", minInt(m.width, 60)))
-		sb.WriteString("\n")
-		sb.WriteString(renderBarChart(rByH, m.width-6, lipgloss.Color("111")))
-		sb.WriteString("\n")
-	}
-
-	// ━━━ Tokens by Hour ━━━
-	if tByH, ok := usageMap["tokens_by_hour"].(map[string]any); ok && len(tByH) > 0 {
-		sb.WriteString(lipgloss.NewStyle().Bold(true).Foreground(colorHighlight).Render(T("usage_tok_by_hour")))
-		sb.WriteString("\n")
-		sb.WriteString(strings.Repeat("─", minInt(m.width, 60)))
-		sb.WriteString("\n")
-		sb.WriteString(renderBarChart(tByH, m.width-6, lipgloss.Color("214")))
-		sb.WriteString("\n")
-	}
-
-	// ━━━ Requests by Day ━━━
-	if rByD, ok := usageMap["requests_by_day"].(map[string]any); ok && len(rByD) > 0 {
-		sb.WriteString(lipgloss.NewStyle().Bold(true).Foreground(colorHighlight).Render(T("usage_req_by_day")))
-		sb.WriteString("\n")
-		sb.WriteString(strings.Repeat("─", minInt(m.width, 60)))
-		sb.WriteString("\n")
-		sb.WriteString(renderBarChart(rByD, m.width-6, lipgloss.Color("76")))
-		sb.WriteString("\n")
-	}
-
-	// ━━━ API Detail Stats ━━━
-	if apis, ok := usageMap["apis"].(map[string]any); ok && len(apis) > 0 {
-		sb.WriteString(lipgloss.NewStyle().Bold(true).Foreground(colorHighlight).Render(T("usage_api_detail")))
-		sb.WriteString("\n")
-		sb.WriteString(strings.Repeat("─", minInt(m.width, 80)))
-		sb.WriteString("\n")
-
-		header := fmt.Sprintf("  %-30s %10s %12s", "API", T("requests"), T("tokens"))
-		sb.WriteString(tableHeaderStyle.Render(header))
-		sb.WriteString("\n")
-
-		for apiName, apiSnap := range apis {
-			if apiMap, ok := apiSnap.(map[string]any); ok {
-				apiReqs := int64(getFloat(apiMap, "total_requests"))
-				apiToks := int64(getFloat(apiMap, "total_tokens"))
-
-				row := fmt.Sprintf("  %-30s %10d %12s",
-					truncate(maskKey(apiName), 30), apiReqs, formatLargeNumber(apiToks))
-				sb.WriteString(lipgloss.NewStyle().Bold(true).Render(row))
-				sb.WriteString("\n")
-
-				// Per-model breakdown
-				if models, ok := apiMap["models"].(map[string]any); ok {
-					for model, v := range models {
-						if stats, ok := v.(map[string]any); ok {
-							mReqs := int64(getFloat(stats, "total_requests"))
-							mToks := int64(getFloat(stats, "total_tokens"))
-							mRow := fmt.Sprintf("    ├─ %-28s %10d %12s",
-								truncate(model, 28), mReqs, formatLargeNumber(mToks))
-							sb.WriteString(tableCellStyle.Render(mRow))
-							sb.WriteString("\n")
-
-							// Token type breakdown from details
-							sb.WriteString(m.renderTokenBreakdown(stats))
-
-							// Latency breakdown from details
-							sb.WriteString(m.renderLatencyBreakdown(stats))
-						}
-					}
-				}
-			}
-		}
-	}
-
-	sb.WriteString("\n")
-	return sb.String()
-}
-
-// renderTokenBreakdown aggregates input/output/cached/reasoning tokens from model details.
-func (m usageTabModel) renderTokenBreakdown(modelStats map[string]any) string {
-	details, ok := modelStats["details"]
-	if !ok {
-		return ""
-	}
-	detailList, ok := details.([]any)
-	if !ok || len(detailList) == 0 {
-		return ""
-	}
-
-	var inputTotal, outputTotal, cachedTotal, reasoningTotal int64
-	for _, d := range detailList {
-		dm, ok := d.(map[string]any)
-		if !ok {
-			continue
-		}
-		tokens, ok := dm["tokens"].(map[string]any)
-		if !ok {
-			continue
-		}
-		inputTotal += int64(getFloat(tokens, "input_tokens"))
-		outputTotal += int64(getFloat(tokens, "output_tokens"))
-		cachedTotal += int64(getFloat(tokens, "cached_tokens"))
-		reasoningTotal += int64(getFloat(tokens, "reasoning_tokens"))
-	}
-
-	if inputTotal == 0 && outputTotal == 0 && cachedTotal == 0 && reasoningTotal == 0 {
-		return ""
-	}
-
-	parts := []string{}
-	if inputTotal > 0 {
-		parts = append(parts, fmt.Sprintf("%s:%s", T("usage_input"), formatLargeNumber(inputTotal)))
-	}
-	if outputTotal > 0 {
-		parts = append(parts, fmt.Sprintf("%s:%s", T("usage_output"), formatLargeNumber(outputTotal)))
-	}
-	if cachedTotal > 0 {
-		parts = append(parts, fmt.Sprintf("%s:%s", T("usage_cached"), formatLargeNumber(cachedTotal)))
-	}
-	if reasoningTotal > 0 {
-		parts = append(parts, fmt.Sprintf("%s:%s", T("usage_reasoning"), formatLargeNumber(reasoningTotal)))
-	}
-
-	return fmt.Sprintf("    │  %s\n",
-		lipgloss.NewStyle().Foreground(colorMuted).Render(strings.Join(parts, "  ")))
-}
-
-// renderLatencyBreakdown aggregates latency_ms from model details and displays avg/min/max.
-func (m usageTabModel) renderLatencyBreakdown(modelStats map[string]any) string {
-	details, ok := modelStats["details"]
-	if !ok {
-		return ""
-	}
-	detailList, ok := details.([]any)
-	if !ok || len(detailList) == 0 {
-		return ""
-	}
-
-	var totalLatency int64
-	var count int
-	var minLatency, maxLatency int64
-	first := true
-
-	for _, d := range detailList {
-		dm, ok := d.(map[string]any)
-		if !ok {
-			continue
-		}
-		latencyMs := int64(getFloat(dm, "latency_ms"))
-		if latencyMs <= 0 {
-			continue
-		}
-		totalLatency += latencyMs
-		count++
-		if first {
-			minLatency = latencyMs
-			maxLatency = latencyMs
-			first = false
-		} else {
-			if latencyMs < minLatency {
-				minLatency = latencyMs
-			}
-			if latencyMs > maxLatency {
-				maxLatency = latencyMs
-			}
-		}
-	}
-
-	if count == 0 {
-		return ""
-	}
-
-	avgLatency := totalLatency / int64(count)
-	return fmt.Sprintf("    │  %s: avg %dms  min %dms  max %dms\n",
-		lipgloss.NewStyle().Foreground(colorMuted).Render(T("usage_time")),
-		avgLatency, minLatency, maxLatency)
-}
-
-// renderBarChart renders a simple ASCII horizontal bar chart.
-func renderBarChart(data map[string]any, maxBarWidth int, barColor lipgloss.Color) string {
-	if maxBarWidth < 10 {
-		maxBarWidth = 10
-	}
-
-	// Sort keys
-	keys := make([]string, 0, len(data))
-	for k := range data {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-
-	// Find max value
-	maxVal := float64(0)
-	for _, k := range keys {
-		v := getFloat(data, k)
-		if v > maxVal {
-			maxVal = v
-		}
-	}
-	if maxVal == 0 {
-		return ""
-	}
-
-	barStyle := lipgloss.NewStyle().Foreground(barColor)
-	var sb strings.Builder
-
-	labelWidth := 12
-	barAvail := maxBarWidth - labelWidth - 12
-	if barAvail < 5 {
-		barAvail = 5
-	}
-
-	for _, k := range keys {
-		v := getFloat(data, k)
-		barLen := int(v / maxVal * float64(barAvail))
-		if barLen < 1 && v > 0 {
-			barLen = 1
-		}
-		bar := strings.Repeat("█", barLen)
-		label := k
-		if len(label) > labelWidth {
-			label = label[:labelWidth]
-		}
-		sb.WriteString(fmt.Sprintf("  %-*s %s %s\n",
-			labelWidth, label,
-			barStyle.Render(bar),
-			lipgloss.NewStyle().Foreground(colorMuted).Render(fmt.Sprintf("%.0f", v)),
-		))
-	}
-
-	return sb.String()
-}

internal/tui/usage_tab_test.go

@@ -1,134 +0,0 @@
-package tui
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestRenderLatencyBreakdown(t *testing.T) {
-	tests := []struct {
-		name         string
-		modelStats   map[string]any
-		wantEmpty    bool
-		wantContains string
-	}{
-		{
-			name:       "no details",
-			modelStats: map[string]any{},
-			wantEmpty:  true,
-		},
-		{
-			name: "empty details",
-			modelStats: map[string]any{
-				"details": []any{},
-			},
-			wantEmpty: true,
-		},
-		{
-			name: "details with zero latency",
-			modelStats: map[string]any{
-				"details": []any{
-					map[string]any{
-						"latency_ms": float64(0),
-					},
-				},
-			},
-			wantEmpty: true,
-		},
-		{
-			name: "single request with latency",
-			modelStats: map[string]any{
-				"details": []any{
-					map[string]any{
-						"latency_ms": float64(1500),
-					},
-				},
-			},
-			wantEmpty:    false,
-			wantContains: "avg 1500ms  min 1500ms  max 1500ms",
-		},
-		{
-			name: "multiple requests with varying latency",
-			modelStats: map[string]any{
-				"details": []any{
-					map[string]any{
-						"latency_ms": float64(100),
-					},
-					map[string]any{
-						"latency_ms": float64(200),
-					},
-					map[string]any{
-						"latency_ms": float64(300),
-					},
-				},
-			},
-			wantEmpty:    false,
-			wantContains: "avg 200ms  min 100ms  max 300ms",
-		},
-		{
-			name: "mixed valid and invalid latency values",
-			modelStats: map[string]any{
-				"details": []any{
-					map[string]any{
-						"latency_ms": float64(500),
-					},
-					map[string]any{
-						"latency_ms": float64(0),
-					},
-					map[string]any{
-						"latency_ms": float64(1500),
-					},
-				},
-			},
-			wantEmpty:    false,
-			wantContains: "avg 1000ms  min 500ms  max 1500ms",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			m := usageTabModel{}
-			result := m.renderLatencyBreakdown(tt.modelStats)
-
-			if tt.wantEmpty {
-				if result != "" {
-					t.Errorf("renderLatencyBreakdown() = %q, want empty string", result)
-				}
-				return
-			}
-
-			if result == "" {
-				t.Errorf("renderLatencyBreakdown() = empty, want non-empty string")
-				return
-			}
-
-			if tt.wantContains != "" && !strings.Contains(result, tt.wantContains) {
-				t.Errorf("renderLatencyBreakdown() = %q, want to contain %q", result, tt.wantContains)
-			}
-		})
-	}
-}
-
-func TestUsageTimeTranslations(t *testing.T) {
-	prevLocale := CurrentLocale()
-	t.Cleanup(func() {
-		SetLocale(prevLocale)
-	})
-
-	tests := []struct {
-		locale string
-		want   string
-	}{
-		{locale: "en", want: "Time"},
-		{locale: "zh", want: "时间"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.locale, func(t *testing.T) {
-			SetLocale(tt.locale)
-			if got := T("usage_time"); got != tt.want {
-				t.Fatalf("T(usage_time) = %q, want %q", got, tt.want)
-			}
-		})
-	}
-}