feat: comprehensive UI feedback for long operations

- Show stream idle status in status line instead of silencing it
- Cap first idle warning at 30s (was half of timeout, e.g. 90s for GLM)
- Add OnThinkingIdle callback — distinguishes "model is thinking" from
  "server is unresponsive" with separate UI treatment (info vs warning)
- Extend stream idle timeout once for thinking models before first content,
  giving GLM up to 6 minutes for complex reasoning tasks
- Fix lastWarningAt accumulation bug (was jumping by streamIdleWarning
  instead of actual 10s interval after first warning)
- Add feedback for agent reflection (up to 30s LLM call), context
  compaction, force-compaction, and background optimization
- Add OnOptimizeStart callback + StatusInfo toast for context optimization
- Show "· running" hint for slow tool calls via previously unused
  slowWarningShown flag
- Notify user when session is compacted after restore to fit model context
- Translate all status_callback messages from Russian to English

Author: ginkida

internal/agent/agent.go

@@ -2388,9 +2388,10 @@ func (a *Agent) executeLoop(ctx context.Context, prompt string, output *strings.
 					if a.treePlanner.ShouldReplan(planTree, firstFailure.result) && replanAttempts < 3 {
 						replanAttempts++
 
-						// Build replan context with reflection
+						// Build replan context with reflection — may invoke LLM (up to 30s)
 						var reflection *Reflection
 						if a.reflector != nil && firstFailure.action.ToolName != "" {
+							a.safeOnText(fmt.Sprintf("\n[Analyzing %s failure...]\n", firstFailure.action.ToolName))
 							reflection = a.reflector.Reflect(ctx, firstFailure.action.ToolName, firstFailure.action.ToolArgs, firstFailure.result.Error)
 						}
 
@@ -3154,6 +3155,7 @@ func (a *Agent) checkAndSummarize(ctx context.Context) error {
 		"agent_id", a.ID,
 		"usage", fmt.Sprintf("%.1f%%", percentUsed*100),
 		"tokens", tokenCount)
+	a.safeOnText(fmt.Sprintf("\n[Compacting context (%.0f%% used)...]\n", percentUsed*100))
 
 	// 3. Summarize on snapshot (potentially slow API call — no lock held)
 	if len(historySnapshot) <= a.summarizeMinMsgs {
@@ -3217,6 +3219,8 @@ func (a *Agent) forceCompactHistory(ctx context.Context) error {
 		return nil // Not enough to compact
 	}
 
+	a.safeOnText(fmt.Sprintf("\n[Force-compacting history (%d messages)...]\n", len(a.history)))
+
 	keepStart := 3  // system prompt + greeting + original task prompt
 	keepEnd := 6
 	keepMiddle := 4 // Top N by importance from middle section
@@ -3825,7 +3829,8 @@ func (a *Agent) executeToolWithReflection(ctx context.Context, call *genai.Funct
 			logging.Info("fix cache hit", "tool", call.Name, "category", category,
 				"hit_count", cacheHit.HitCount)
 		} else {
-			// Cache miss: full Reflect pipeline (unchanged)
+			// Cache miss: full Reflect pipeline — may invoke LLM (up to 30s)
+			a.safeOnText(fmt.Sprintf("\n[Analyzing %s error...]\n", call.Name))
 			reflection = a.reflector.Reflect(ctx, call.Name, call.Args, result.Content)
 		}
 

internal/app/app.go

@@ -354,6 +354,7 @@ func (a *App) Run() error {
 					"messages_after", len(a.session.GetHistory()),
 					"tokens_estimated", tokens,
 					"model_limit", limits.MaxInputTokens)
+				a.tui.AddSystemMessage(fmt.Sprintf("Compacted session to fit model context (removed %d messages)", truncated))
 			}
 		}
 	}

internal/app/app_handlers.go

@@ -52,7 +52,7 @@ func (a *App) promptPermission(ctx context.Context, req *permission.Request) (pe
 			if a.program != nil {
 				a.program.Send(ui.StatusUpdateMsg{
 					Type:    ui.StatusStreamIdle,
-					Message: fmt.Sprintf("Ожидание разрешения для %s...", req.ToolName),
+					Message: fmt.Sprintf("Waiting for permission: %s...", req.ToolName),
 				})
 			}
 			// Reset timer for next reminder

internal/app/builder.go

@@ -1629,6 +1629,14 @@ func (b *Builder) wireDependencies() error {
 				app.tui.AddSystemMessage(msg)
 			}
 		}
+		b.contextManager.OnOptimizeStart = func(reason string) {
+			if app.program != nil {
+				app.safeSendToProgram(ui.StatusUpdateMsg{
+					Type:    ui.StatusInfo,
+					Message: fmt.Sprintf("Optimizing context (%s)...", reason),
+				})
+			}
+		}
 	}
 
 	// Set up background task tracking callbacks for UI

internal/app/status_callback.go

@@ -19,7 +19,7 @@ func (c *appStatusCallback) OnRetry(attempt, maxAttempts int, delay time.Duratio
 		return
 	}
 
-	msg := fmt.Sprintf("Повторная попытка %d/%d через %s (%s)",
+	msg := fmt.Sprintf("Retry %d/%d in %s (%s)",
 		attempt, maxAttempts, delay.Round(time.Second), reason)
 
 	c.app.program.Send(ui.StatusUpdateMsg{
@@ -40,7 +40,7 @@ func (c *appStatusCallback) OnRateLimit(waitTime time.Duration) {
 		return
 	}
 
-	msg := fmt.Sprintf("Rate limit, ожидание %s...", waitTime.Round(time.Second))
+	msg := fmt.Sprintf("Rate limit, waiting %s...", waitTime.Round(time.Second))
 
 	c.app.program.Send(ui.StatusUpdateMsg{
 		Type:    ui.StatusRateLimit,
@@ -57,9 +57,9 @@ func (c *appStatusCallback) OnStreamIdle(elapsed time.Duration) {
 		return
 	}
 
-	msg := fmt.Sprintf("Ожидание ответа %s...", elapsed.Round(time.Second))
+	msg := fmt.Sprintf("Waiting for response %s...", elapsed.Round(time.Second))
 	if elapsed >= 20*time.Second {
-		msg = fmt.Sprintf("Ожидание ответа %s... (ESC для отмены)", elapsed.Round(time.Second))
+		msg = fmt.Sprintf("Waiting for response %s... (ESC to cancel)", elapsed.Round(time.Second))
 	}
 
 	c.app.program.Send(ui.StatusUpdateMsg{
@@ -71,6 +71,27 @@ func (c *appStatusCallback) OnStreamIdle(elapsed time.Duration) {
 	})
 }
 
+// OnThinkingIdle is called when a thinking-enabled model is in its silent reasoning phase.
+func (c *appStatusCallback) OnThinkingIdle(elapsed time.Duration, provider string) {
+	if c.app == nil || c.app.program == nil {
+		return
+	}
+
+	msg := fmt.Sprintf("%s is thinking %s...", provider, elapsed.Round(time.Second))
+	if elapsed >= 60*time.Second {
+		msg = fmt.Sprintf("%s is thinking %s... (ESC to cancel)", provider, elapsed.Round(time.Second))
+	}
+
+	c.app.program.Send(ui.StatusUpdateMsg{
+		Type:    ui.StatusThinkingIdle,
+		Message: msg,
+		Details: map[string]any{
+			"elapsed":  elapsed,
+			"provider": provider,
+		},
+	})
+}
+
 // OnStreamResume is called when the stream resumes after being idle.
 func (c *appStatusCallback) OnStreamResume() {
 	if c.app == nil || c.app.program == nil {
@@ -92,7 +113,7 @@ func (c *appStatusCallback) OnError(err error, recoverable bool) {
 
 	msg := err.Error()
 	if recoverable {
-		msg = "Восстанавливаемая ошибка: " + msg
+		msg = "Recoverable error: " + msg
 	}
 	ft := client.DetectFailureTelemetry(err)
 

internal/client/anthropic.go

@@ -862,8 +862,11 @@ func (c *AnthropicClient) doStreamRequest(ctx context.Context, requestBody map[s
 
 	// Stream idle timeout (configurable, default 30s between chunks)
 	streamIdleTimeout := c.config.StreamIdleTimeout
-	// Stream idle warning - half of idle timeout
+	// Stream idle warning - half of idle timeout, capped at 30s for faster feedback
 	streamIdleWarning := streamIdleTimeout / 2
+	if streamIdleWarning > 30*time.Second {
+		streamIdleWarning = 30 * time.Second
+	}
 
 	// Capture status callback for goroutine
 	c.mu.RLock()
@@ -931,10 +934,11 @@ func (c *AnthropicClient) doStreamRequest(ctx context.Context, requestBody map[s
 
 		eventCount := 0
 		contentReceived := false
+		initialTimeoutExtended := false // Track whether we've already extended for thinking phase
 		idleTimer := time.NewTimer(streamIdleTimeout)
 		defer idleTimer.Stop()
 
-		// Warning timer for UI feedback (fires at 15s, then again at 25s)
+		// Warning timer for UI feedback (fires at 30s max, then every 10s)
 		warningTimer := time.NewTimer(streamIdleWarning)
 		defer warningTimer.Stop()
 		lastWarningAt := time.Duration(0)
@@ -956,16 +960,38 @@ func (c *AnthropicClient) doStreamRequest(ctx context.Context, requestBody map[s
 
 				case <-warningTimer.C:
 					// Stream idle warning - notify UI
-					lastWarningAt += streamIdleWarning
+					if lastWarningAt == 0 {
+						lastWarningAt = streamIdleWarning
+					} else {
+						lastWarningAt += 10 * time.Second // Match the actual reset interval
+					}
 					if statusCb != nil {
-						statusCb.OnStreamIdle(lastWarningAt)
+						// Distinguish thinking phase from generic idle
+						if !contentReceived && c.config.EnableThinking {
+							statusCb.OnThinkingIdle(lastWarningAt, c.config.Provider)
+						} else {
+							statusCb.OnStreamIdle(lastWarningAt)
+						}
 					}
 					// Reset for next warning (every 10 seconds after first)
 					warningTimer.Reset(10 * time.Second)
 					// Continue waiting in the same select
 					continue waitLoop
 
 				case <-idleTimer.C:
+					// If thinking is enabled and no content received yet, the model
+					// is likely in a silent reasoning phase. Extend the timeout once
+					// to avoid killing the request prematurely.
+					if !contentReceived && !initialTimeoutExtended && c.config.EnableThinking {
+						initialTimeoutExtended = true
+						logging.Info("extending idle timeout for thinking model — no content yet",
+							"provider", c.config.Provider, "original_timeout", streamIdleTimeout)
+						idleTimer.Reset(streamIdleTimeout)
+						if statusCb != nil {
+							statusCb.OnThinkingIdle(streamIdleTimeout, c.config.Provider)
+						}
+						continue waitLoop
+					}
 					logging.Warn("stream idle timeout exceeded", "timeout", streamIdleTimeout, "partial", contentReceived)
 					chunks <- ResponseChunk{
 						Error: &ErrStreamIdleTimeout{Timeout: streamIdleTimeout, Partial: contentReceived},

internal/client/status.go

@@ -20,6 +20,11 @@ type StatusCallback interface {
 	// elapsed is the time since the last data was received.
 	OnStreamIdle(elapsed time.Duration)
 
+	// OnThinkingIdle is called when a thinking-enabled model is in its silent
+	// reasoning phase (no content received yet). Unlike OnStreamIdle, this tells
+	// the UI that the delay is expected — the model is deliberately thinking.
+	OnThinkingIdle(elapsed time.Duration, provider string)
+
 	// OnStreamResume is called when the stream resumes after being idle.
 	OnStreamResume()
 
@@ -42,6 +47,9 @@ func (d *DefaultStatusCallback) OnRateLimit(waitTime time.Duration) {}
 // OnStreamIdle does nothing.
 func (d *DefaultStatusCallback) OnStreamIdle(elapsed time.Duration) {}
 
+// OnThinkingIdle does nothing.
+func (d *DefaultStatusCallback) OnThinkingIdle(elapsed time.Duration, provider string) {}
+
 // OnStreamResume does nothing.
 func (d *DefaultStatusCallback) OnStreamResume() {}
 

internal/context/manager.go

@@ -65,6 +65,9 @@ type ContextManager struct {
 
 	// Notification callback when context is compacted
 	OnCompact func(oldTokens, newTokens, removedMessages int, reason string)
+
+	// Notification callback when background optimization starts (for UI feedback)
+	OnOptimizeStart func(reason string)
 }
 
 // NewContextManager creates a new context manager.
@@ -366,6 +369,7 @@ func (m *ContextManager) PrepareForRequest(ctx context.Context) error {
 
 	// Optimize if near limit — launch in background to avoid blocking
 	if usage.NearLimit && m.summarizer != nil && m.config.EnableAutoSummary {
+		m.notifyOptimizeStart("context near token limit")
 		m.backgroundOptimize(ctx)
 	}
 
@@ -378,6 +382,7 @@ func (m *ContextManager) PrepareForRequest(ctx context.Context) error {
 					"current_tokens", tokens,
 					"predicted_tokens", predicted,
 					"predicted_pct", predUsage.PercentUsed)
+				m.notifyOptimizeStart("predictive — approaching token limit")
 				m.backgroundOptimize(ctx)
 			}
 		}
@@ -390,13 +395,21 @@ func (m *ContextManager) PrepareForRequest(ctx context.Context) error {
 			logging.Info("message count summarization triggered",
 				"history_len", historyLen,
 				"max_history", maxHistory)
+			m.notifyOptimizeStart("conversation history growing large")
 			m.backgroundOptimize(ctx)
 		}
 	}
 
 	return nil
 }
 
+// notifyOptimizeStart fires the OnOptimizeStart callback if registered.
+func (m *ContextManager) notifyOptimizeStart(reason string) {
+	if m.OnOptimizeStart != nil {
+		m.OnOptimizeStart(reason)
+	}
+}
+
 // backgroundOptimize runs context optimization in a background goroutine.
 // Only one optimization runs at a time; concurrent calls are no-ops.
 func (m *ContextManager) backgroundOptimize(ctx context.Context) {

internal/ui/tui.go

@@ -50,6 +50,9 @@ type Model struct {
 	lastActivityTime time.Time // Last time we received any activity (tool call, stream, etc.)
 	slowWarningShown bool      // Whether we've shown the slow warning for current operation
 
+	// Stream idle feedback (server slow to respond)
+	streamIdleMsg string // Non-empty when stream is idle — shown in status line
+
 	// Rate limiting / debounce for message submission
 	lastSubmitTime time.Time
 	minSubmitDelay time.Duration // Minimum delay between submissions (default: 500ms)
@@ -1333,6 +1336,7 @@ func (m *Model) handleMessageTypes(msg tea.Msg) tea.Cmd {
 		m.streamStartTime = time.Now() // Reset timeout on streaming activity
 		m.lastActivityTime = time.Now()
 		m.slowWarningShown = false
+		m.streamIdleMsg = "" // Server responded — clear idle warning
 		m.state = StateStreaming
 		m.processingLabel = "" // Text streaming is the feedback itself
 
@@ -1351,6 +1355,7 @@ func (m *Model) handleMessageTypes(msg tea.Msg) tea.Cmd {
 		m.streamStartTime = time.Now() // Reset timeout on tool activity
 		m.lastActivityTime = time.Now()
 		m.slowWarningShown = false
+		m.streamIdleMsg = "" // Server responded — clear idle warning
 		m.processingLabel = "" // Tool name takes over in status bar
 
 		// Close thinking block when tool call starts
@@ -1495,6 +1500,7 @@ func (m *Model) handleMessageTypes(msg tea.Msg) tea.Cmd {
 		m.currentTool = ""
 		m.currentToolInfo = ""
 		m.processingLabel = ""
+		m.streamIdleMsg = "" // Clear idle warning
 		m.loopIteration = 0
 		m.loopToolsUsed = 0
 		m.activeToolCalls = nil
@@ -1537,6 +1543,7 @@ func (m *Model) handleMessageTypes(msg tea.Msg) tea.Cmd {
 		m.currentTool = ""
 		m.currentToolInfo = ""
 		m.processingLabel = ""
+		m.streamIdleMsg = "" // Clear idle warning
 		m.loopIteration = 0
 		m.loopToolsUsed = 0
 		m.activeToolCalls = nil
@@ -2026,8 +2033,15 @@ func (m *Model) handleMessageTypes(msg tea.Msg) tea.Cmd {
 				m.rateLimitWaitUntil = time.Now().Add(wt)
 			}
 		case StatusStreamIdle:
-			// Silent
+			firstWarning := m.streamIdleMsg == ""
+			if msg.Message != "" {
+				m.streamIdleMsg = msg.Message
+			}
+			if firstWarning && m.toastManager != nil && msg.Message != "" {
+				m.toastManager.ShowWarning(msg.Message)
+			}
 		case StatusStreamResume:
+			m.streamIdleMsg = ""
 			m.retryAttempt = 0
 			m.retryMax = 0
 			m.rateLimitWaitUntil = time.Time{}
@@ -2039,6 +2053,19 @@ func (m *Model) handleMessageTypes(msg tea.Msg) tea.Cmd {
 			if m.toastManager != nil {
 				m.toastManager.ShowWarning(msg.Message)
 			}
+		case StatusInfo:
+			if m.toastManager != nil && msg.Message != "" {
+				m.toastManager.Show(ToastInfo, "", msg.Message, 4*time.Second)
+			}
+		case StatusThinkingIdle:
+			// Model is deliberately thinking — show distinct from generic "idle"
+			firstWarning := m.streamIdleMsg == ""
+			if msg.Message != "" {
+				m.streamIdleMsg = msg.Message
+			}
+			if firstWarning && m.toastManager != nil && msg.Message != "" {
+				m.toastManager.Show(ToastInfo, "", msg.Message, 6*time.Second)
+			}
 		}
 	}
 
@@ -2382,6 +2409,16 @@ func (m Model) View() string {
 				status += "  " + lipgloss.NewStyle().Foreground(durationColor).Render(format.Duration(elapsed))
 			}
 
+			// Show stream idle indicator when server is slow to respond
+			if m.streamIdleMsg != "" {
+				idleStyle := lipgloss.NewStyle().Foreground(ColorWarning)
+				status += "  " + idleStyle.Render("· " + m.streamIdleMsg)
+			} else if m.slowWarningShown && m.currentTool != "" {
+				// Tool is running longer than expected — show brief hint
+				slowStyle := lipgloss.NewStyle().Foreground(ColorDim)
+				status += "  " + slowStyle.Render("· running")
+			}
+
 			// Plan step context
 			if m.planProgress != nil && m.planProgressMode {
 				stepInfo := fmt.Sprintf(" [step %d/%d]",

internal/ui/tui_types.go

@@ -328,6 +328,8 @@ const (
 	StatusStreamResume
 	StatusRecoverableError
 	StatusCancelled
+	StatusInfo
+	StatusThinkingIdle
 )
 
 // StatusUpdateMsg carries status updates from clients to the UI.