xonecas.io
60255
Zn

Zoea-Nova / files

Zoea-Nova / internal / tui / app.go

30.8 KB
1// Package tui provides the terminal user interface for Zoea Nova.
2package tui
3
4import (
5	"fmt"
6	"sort"
7	"strings"
8	"time"
9
10	"github.com/charmbracelet/bubbles/key"
11	"github.com/charmbracelet/bubbles/spinner"
12	"github.com/charmbracelet/bubbles/viewport"
13	tea "github.com/charmbracelet/bubbletea"
14	"github.com/charmbracelet/lipgloss"
15	"github.com/xonecas/zoea-nova/internal/config"
16	"github.com/xonecas/zoea-nova/internal/core"
17	"github.com/xonecas/zoea-nova/internal/store"
18)
19
20// View represents the current view mode.
21type View int
22
23const (
24	ViewDashboard View = iota
25	ViewFocus
26)
27
28// InputStage represents stages in multi-step input flows.
29type InputStage int
30
31const (
32	InputStageName InputStage = iota
33	InputStageProvider
34)
35
36// Model is the main TUI model.
37type Model struct {
38	commander *core.Commander
39	store     *store.Store
40	eventCh   <-chan core.Event
41	config    *config.Config
42
43	view        View
44	width       int
45	height      int
46	selectedIdx int
47	showHelp    bool
48	verboseJSON bool // show full JSON trees without truncation
49
50	input   InputModel
51	myses   []MysisInfo
52	logs    []LogEntry
53	focusID string
54
55	// Multi-stage input for mysis creation
56	inputStage           InputStage
57	pendingMysisName     string
58	pendingMysisProvider string
59
60	pendingProvider string
61	startSwarm      bool // auto-start idle myses on launch
62
63	// Swarm broadcast history
64	swarmMessages []SwarmMessage
65
66	// Current swarm aggregate tick
67	currentTick int64
68
69	// Test-only: override time.Now() for deterministic timestamps in tests
70	testTime *time.Time
71
72	spinner     spinner.Model
73	loadingSet  map[string]bool // mysisIDs currently loading
74	sending     bool
75	sendingMode InputMode
76
77	// Conversation viewport
78	viewport           viewport.Model
79	viewportTotalLines int // total lines in viewport content
80
81	// Sidebar scroll state
82	sidebarScrollOffset int // current scroll position for game state sidebar
83	sidebarTotalLines   int // total lines in sidebar content
84
85	// Network activity indicator
86	netIndicator     NetIndicator
87	activeNetworkOps int // Count of active network operations (LLM/MCP calls)
88
89	providerErrorTimes []time.Time
90
91	onQuit func() // Callback to run before quitting
92	err    error
93}
94
95const (
96	providerErrorWindow     = 10 * time.Minute
97	maxConversationEntries  = 500 // Maximum conversation log entries to load for performance
98	MaxConversationMessages = 500 // Maximum conversation messages to display in focus view
99)
100
101// SwarmMessage represents a broadcast message for display.
102type SwarmMessage struct {
103	SenderID  string
104	Content   string
105	CreatedAt time.Time
106}
107
108// EventMsg wraps a core event for the TUI.
109type EventMsg struct {
110	Event core.Event
111}
112
113// New creates a new TUI model.
114func New(commander *core.Commander, s *store.Store, eventCh <-chan core.Event, startSwarm bool, cfg *config.Config) Model {
115	// Use provided config (already loaded in main.go)
116
117	// Initialize spinner with hexagonal theme (matching logo)
118	sp := spinner.New()
119	sp.Spinner = spinner.Spinner{
120		Frames: []string{"⬡", "⬢", "⬡", "⬢", "⬦", "⬥", "⬦", "⬥"},
121		FPS:    time.Second / 8, // 8 frames per second
122	}
123	sp.Style = lipgloss.NewStyle().Foreground(colorBrand)
124
125	// Initialize viewport for conversation scrolling
126	vp := viewport.New(80, 20)
127	vp.Style = logStyle
128
129	return Model{
130		commander:    commander,
131		store:        s,
132		eventCh:      eventCh,
133		config:       cfg,
134		view:         ViewDashboard,
135		input:        NewInputModel(),
136		myses:        []MysisInfo{},
137		inputStage:   InputStageName,
138		spinner:      sp,
139		loadingSet:   make(map[string]bool),
140		viewport:     vp,
141		netIndicator: NewNetIndicator(),
142		startSwarm:   startSwarm,
143	}
144}
145
146// SetOnQuit sets a callback to run before the TUI quits.
147func (m *Model) SetOnQuit(fn func()) {
148	m.onQuit = fn
149}
150
151// Init initializes the model.
152func (m Model) Init() tea.Cmd {
153	// Auto-start idle myses if flag enabled
154	if m.startSwarm {
155		go m.autoStartIdleMyses()
156	}
157
158	return tea.Batch(
159		m.netIndicator.Init(),
160		m.refreshMyses(),
161		m.listenForEvents(),
162		m.spinner.Tick,
163	)
164}
165
166// autoStartIdleMyses starts all myses in idle state (no error).
167func (m Model) autoStartIdleMyses() {
168	myses := m.commander.ListMyses()
169	for _, mysis := range myses {
170		// Start myses that are not errored (idle state)
171		if mysis.LastError() == nil {
172			_ = m.commander.StartMysis(mysis.ID())
173		}
174	}
175}
176
177// Update handles messages.
178func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
179	var cmds []tea.Cmd
180
181	m.pruneProviderErrors(time.Now())
182
183	switch msg := msg.(type) {
184	case tea.WindowSizeMsg:
185		m.width = msg.Width
186		m.height = msg.Height
187		m.input.SetWidth(msg.Width - 4)
188
189		// Update viewport size (account for all UI chrome)
190		// Layout in RenderFocusViewWithViewport:
191		//   - Header: 2 lines (mysis name + ID/created)
192		//   - Info panel: 3 lines (top border + content + bottom border)
193		//   - Title row: 1 line (GAME STATE + CONVERSATION LOG titles)
194		//   - Content: max(sidebar_lines, vp.Height) lines (sidebar + conversation side-by-side)
195		//   - Bottom border: 1 line
196		//   - Footer: 1 line (hints)
197		// Added in View():
198		//   - Newline: 1 line (before message bar)
199		//   - Message bar: 1 line
200		//   - Newline: 1 line (before status bar)
201		//   - Status bar: 1 line
202		// Total: (2+3+1+1+1) + vp.Height + (1+1+1+1) = 12 + vp.Height
203		// Therefore: vp.Height = msg.Height - 12
204		vpHeight := msg.Height - 12
205		if vpHeight < 5 {
206			vpHeight = 5
207		}
208		// Viewport width must match the conversation log width calculation in focus.go
209		// Two-column layout: Sidebar (33% of width) + Gap (3: space+│+space) + Conversation
210		// Sidebar takes 33% of terminal width (multiply first to avoid precision loss)
211		// Viewport content width = conversation - 2 (for scrollbar)
212		sidebarWidth := (msg.Width * 33) / 100
213		const columnGap = 3
214		conversationWidth := msg.Width - sidebarWidth - columnGap
215		m.viewport.Width = conversationWidth - 2 // -2 for scrollbar
216		m.viewport.Height = vpHeight
217
218		// Re-render content if in focus view
219		if m.view == ViewFocus {
220			m.updateViewportContent()
221		}
222
223	case tea.MouseMsg:
224		// Handle mouse wheel scrolling in focus view
225		if m.view == ViewFocus {
226			return m.handleMouseInFocus(msg)
227		}
228		// For other views, let viewport handle it
229		var cmd tea.Cmd
230		m.viewport, cmd = m.viewport.Update(msg)
231		return m, cmd
232
233	case tea.KeyMsg:
234		// Handle input mode first
235		if m.input.IsActive() {
236			return m.handleInputKey(msg)
237		}
238
239		// Handle help toggle
240		if key.Matches(msg, keys.Help) {
241			m.showHelp = !m.showHelp
242			return m, nil
243		}
244
245		// Close help if shown
246		if m.showHelp {
247			m.showHelp = false
248			return m, nil
249		}
250
251		// Handle global keys
252		switch {
253		case key.Matches(msg, keys.Quit):
254			// Call cleanup callback before quitting
255			if m.onQuit != nil {
256				m.onQuit()
257			}
258			return m, tea.Quit
259
260		case key.Matches(msg, keys.Escape):
261			if m.view == ViewFocus {
262				m.view = ViewDashboard
263				m.focusID = ""
264			}
265			return m, nil
266		}
267
268		// View-specific keys
269		if m.view == ViewDashboard {
270			return m.handleDashboardKey(msg)
271		} else {
272			return m.handleFocusKey(msg)
273		}
274
275	case EventMsg:
276		// Don't re-schedule if channel closed (zero-value event)
277		if msg.Event.Type == "" {
278			return m, nil
279		}
280		m.handleEvent(msg.Event)
281		return m, m.listenForEvents()
282
283	case refreshMysesMsg:
284		m.refreshMysisList()
285		m.refreshSwarmMessages()
286		m.refreshTick()
287
288	case spinner.TickMsg:
289		var cmd tea.Cmd
290		m.spinner, cmd = m.spinner.Update(msg)
291		return m, cmd
292
293	case sendMessageResult:
294		// Message finished sending (success or failure)
295		delete(m.loadingSet, msg.mysisID)
296		if msg.err != nil {
297			m.err = msg.err
298		}
299		// Check if any loading is still active
300		if len(m.loadingSet) == 0 {
301			m.netIndicator.SetActivity(NetActivityIdle)
302			m.sending = false
303			m.sendingMode = InputModeNone
304			m.input.Reset()
305		}
306		// Don't refresh logs here - EventMysisMessage and EventMysisResponse handle that
307
308	case broadcastResult:
309		// Broadcast finished - clear all loading states
310		m.loadingSet = make(map[string]bool)
311		m.netIndicator.SetActivity(NetActivityIdle)
312		m.sending = false
313		m.sendingMode = InputModeNone
314		m.input.Reset()
315		if msg.err != nil {
316			m.err = msg.err
317		}
318		// Refresh swarm messages to show the new broadcast
319		m.refreshSwarmMessages()
320
321	case NetIndicatorTickMsg:
322		var cmd tea.Cmd
323		m.netIndicator, cmd = m.netIndicator.Update(msg)
324		return m, cmd
325	}
326
327	return m, tea.Batch(cmds...)
328}
329
330// View renders the UI.
331func (m Model) View() string {
332	if m.width == 0 || m.height == 0 {
333		return "Loading..."
334	}
335
336	// Check for minimum terminal dimensions
337	const minWidth = 80
338	const minHeight = 20
339	if m.width < minWidth || m.height < minHeight {
340		warning := lipgloss.NewStyle().
341			Foreground(lipgloss.Color("#FF5555")).
342			Bold(true).
343			Render(fmt.Sprintf("Terminal too small!\n\nMinimum size: %dx%d\nCurrent size: %dx%d\n\nPlease resize your terminal.",
344				minWidth, minHeight, m.width, m.height))
345		return warning
346	}
347
348	var content string
349
350	// Check if currently focused mysis is loading
351	isLoading := m.loadingSet[m.focusID]
352
353	// Reserve space for status bar
354	contentHeight := m.height - 1
355
356	if m.showHelp {
357		content = RenderHelp(m.width, contentHeight)
358	} else if m.view == ViewFocus {
359		focusIndex, totalMyses := m.focusPosition(m.focusID)
360
361		// Get game state snapshots for focused mysis
362		var gameStateSnapshots []*store.GameStateSnapshot
363		focusMysis := m.mysisByID(m.focusID)
364		if focusMysis.AccountUsername != "" {
365			snapshots, err := m.store.GetAllGameStateSnapshots(focusMysis.AccountUsername)
366			if err == nil {
367				gameStateSnapshots = snapshots
368			}
369		}
370
371		content = RenderFocusViewWithViewport(focusMysis, m.viewport, m.width, isLoading, m.spinner.View(), m.verboseJSON, m.viewportTotalLines, focusIndex, totalMyses, m.currentTick, gameStateSnapshots, m.sidebarScrollOffset, m.err)
372	} else {
373		// Convert swarm messages for display (reversed so most recent is first)
374		swarmInfos := make([]SwarmMessageInfo, len(m.swarmMessages))
375		for i, msg := range m.swarmMessages {
376			// Reverse order: most recent first
377			swarmInfos[len(m.swarmMessages)-1-i] = SwarmMessageInfo{
378				SenderID:   msg.SenderID,
379				SenderName: m.mysisNameByID(msg.SenderID),
380				Content:    msg.Content,
381				CreatedAt:  msg.CreatedAt,
382			}
383		}
384		content = RenderDashboard(m.myses, swarmInfos, m.selectedIdx, m.width, contentHeight-3, m.loadingSet, m.spinner.View(), m.currentTick, m.err)
385	}
386
387	// Always show message bar
388	sendingLabel := ""
389	if m.sending {
390		switch m.sendingMode {
391		case InputModeBroadcast:
392			sendingLabel = "Broadcasting..."
393		case InputModeMessage:
394			sendingLabel = "Sending message..."
395		default:
396			sendingLabel = "Sending..."
397		}
398	}
399	content += "\n" + m.input.ViewAlways(m.width, m.sending, sendingLabel, m.spinner.View())
400
401	// Build status bar
402	statusBar := m.renderStatusBar()
403
404	return content + "\n" + statusBar
405}
406
407// renderStatusBar renders the bottom status bar with activity indicator, tick, and state counts.
408// Layout: [activity indicator]  |  T#### ⬡ [HH:MM]  |  [state icons + counts]
409func (m Model) renderStatusBar() string {
410	// Left segment: Activity indicator (LLM/MCP/IDLE)
411	leftSegment := m.netIndicator.View()
412
413	// Middle segment: Tick + timestamp
414	middleSegment := m.renderTickTimestamp()
415
416	// Right segment: State counts with animated icons
417	rightSegment := m.renderStateCounts()
418
419	// Calculate widths
420	leftWidth := lipgloss.Width(leftSegment)
421	middleWidth := lipgloss.Width(middleSegment)
422	rightWidth := lipgloss.Width(rightSegment)
423
424	// Separator style
425	separators := lipgloss.NewStyle().Foreground(colorMuted).Render(" | ")
426	sepWidth := lipgloss.Width(separators)
427
428	// Calculate center position for middle segment
429	centerPos := m.width / 2
430	middleStart := centerPos - (middleWidth / 2)
431
432	// Calculate padding to center the middle segment
433	// Left side: leftSegment + separator + padding
434	leftSideWidth := leftWidth + sepWidth
435	leftPad := middleStart - leftSideWidth
436	if leftPad < 1 {
437		leftPad = 1
438	}
439
440	// Right side: padding + separator + rightSegment
441	rightSideStart := middleStart + middleWidth
442	rightPad := m.width - rightSideStart - sepWidth - rightWidth
443	if rightPad < 1 {
444		rightPad = 1
445	}
446
447	// Style the status bar
448	barStyle := lipgloss.NewStyle().
449		Background(colorBorder).
450		Foreground(colorBrand).
451		Width(m.width)
452
453	bar := leftSegment +
454		separators +
455		strings.Repeat(" ", leftPad) +
456		middleSegment +
457		strings.Repeat(" ", rightPad) +
458		separators +
459		rightSegment
460
461	return barStyle.Render(bar)
462}
463
464// renderStateCounts renders the state counts with animated icons.
465// Format: ⬡ 3  ◦ 2  ◌ 1  ✖ 0
466func (m Model) renderStateCounts() string {
467	// Count states
468	counts := map[string]int{
469		"running": 0,
470		"idle":    0,
471		"stopped": 0,
472		"errored": 0,
473	}
474
475	for _, mysis := range m.myses {
476		counts[mysis.State]++
477	}
478
479	// Get spinner frame for running/loading states
480	spinnerFrame := m.spinner.View()
481
482	// Build state count segments
483	var parts []string
484
485	// Running: animated spinner
486	if counts["running"] > 0 {
487		icon := lipgloss.NewStyle().Foreground(colorBrand).Render(spinnerFrame)
488		count := fmt.Sprintf("%d", counts["running"])
489		parts = append(parts, icon+" "+count)
490	}
491
492	// Idle: ◦
493	if counts["idle"] > 0 {
494		icon := stateIdleStyle.Render("◦")
495		count := fmt.Sprintf("%d", counts["idle"])
496		parts = append(parts, icon+" "+count)
497	}
498
499	// Stopped: ◌
500	if counts["stopped"] > 0 {
501		icon := stateStoppedStyle.Render("◌")
502		count := fmt.Sprintf("%d", counts["stopped"])
503		parts = append(parts, icon+" "+count)
504	}
505
506	// Errored: ✖
507	if counts["errored"] > 0 {
508		icon := stateErroredStyle.Render("✖")
509		count := fmt.Sprintf("%d", counts["errored"])
510		parts = append(parts, icon+" "+count)
511	}
512
513	if len(parts) == 0 {
514		return dimmedStyle.Render("(no myses)")
515	}
516
517	return strings.Join(parts, "  ")
518}
519
520// renderTickTimestamp renders the tick + timestamp in format: T#### ⬡ [HH:MM]
521func (m Model) renderTickTimestamp() string {
522	// Get current time (or test time override)
523	var now time.Time
524	if m.testTime != nil {
525		now = *m.testTime
526	} else {
527		now = time.Now()
528	}
529
530	// Use the shared formatter from styles.go
531	// formatTickTimestamp returns pre-styled string with colors
532	return formatTickTimestamp(m.currentTick, now)
533}
534
535func (m Model) handleDashboardKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
536	switch {
537	case key.Matches(msg, keys.Up), key.Matches(msg, keys.ShiftTab):
538		if m.selectedIdx > 0 {
539			m.selectedIdx--
540		}
541
542	case key.Matches(msg, keys.Down), key.Matches(msg, keys.Tab):
543		if m.selectedIdx < len(m.myses)-1 {
544			m.selectedIdx++
545		}
546
547	case key.Matches(msg, keys.Enter):
548		if len(m.myses) > 0 && m.selectedIdx < len(m.myses) {
549			m.focusID = m.myses[m.selectedIdx].ID
550			m.view = ViewFocus
551			m.loadMysisLogs()
552			// Start at bottom when entering focus view
553			m.viewport.GotoBottom()
554		}
555
556	case key.Matches(msg, keys.NewMysis):
557		m.input.SetMode(InputModeNewMysis, "")
558		m.inputStage = InputStageName // Reset to name stage
559		m.pendingMysisName = ""
560		m.pendingMysisProvider = ""
561		return m, m.input.Focus()
562
563	case key.Matches(msg, keys.Delete):
564		if len(m.myses) > 0 && m.selectedIdx < len(m.myses) {
565			id := m.myses[m.selectedIdx].ID
566			m.err = m.commander.DeleteMysis(id, true)
567			m.refreshMysisList()
568			if m.selectedIdx >= len(m.myses) && m.selectedIdx > 0 {
569				m.selectedIdx--
570			}
571		}
572
573	case key.Matches(msg, keys.Relaunch):
574		if len(m.myses) > 0 && m.selectedIdx < len(m.myses) {
575			id := m.myses[m.selectedIdx].ID
576			m.err = m.commander.StartMysis(id)
577		}
578
579	case key.Matches(msg, keys.Stop):
580		if len(m.myses) > 0 && m.selectedIdx < len(m.myses) {
581			id := m.myses[m.selectedIdx].ID
582			m.err = m.commander.StopMysis(id)
583		}
584
585	case key.Matches(msg, keys.Broadcast):
586		m.input.SetMode(InputModeBroadcast, "")
587		return m, m.input.Focus()
588
589	case key.Matches(msg, keys.Message):
590		if len(m.myses) > 0 && m.selectedIdx < len(m.myses) {
591			id := m.myses[m.selectedIdx].ID
592			m.input.SetMode(InputModeMessage, id)
593			return m, m.input.Focus()
594		}
595
596	case key.Matches(msg, keys.Configure):
597		if len(m.myses) > 0 && m.selectedIdx < len(m.myses) {
598			id := m.myses[m.selectedIdx].ID
599			m.input.SetMode(InputModeConfigProvider, id)
600			return m, m.input.Focus()
601		}
602	}
603
604	return m, nil
605}
606
607func (m Model) handleFocusKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
608	switch {
609	case key.Matches(msg, keys.Message):
610		m.input.SetMode(InputModeMessage, m.focusID)
611		return m, m.input.Focus()
612
613	case key.Matches(msg, keys.Relaunch):
614		m.err = m.commander.StartMysis(m.focusID)
615		return m, nil
616
617	case key.Matches(msg, keys.Stop):
618		m.err = m.commander.StopMysis(m.focusID)
619		return m, nil
620
621	case key.Matches(msg, keys.Configure):
622		m.input.SetMode(InputModeConfigProvider, m.focusID)
623		return m, m.input.Focus()
624
625	case key.Matches(msg, keys.Broadcast):
626		m.input.SetMode(InputModeBroadcast, "")
627		return m, m.input.Focus()
628
629	case key.Matches(msg, keys.End):
630		// Go to bottom
631		m.viewport.GotoBottom()
632		return m, nil
633
634	case key.Matches(msg, keys.VerboseToggle):
635		m.verboseJSON = !m.verboseJSON
636		// Re-render viewport content with new verbose setting
637		m.updateViewportContent()
638		return m, nil
639
640	// Sidebar scrolling (Shift+Up/Down for sidebar, plain Up/Down for conversation)
641	case msg.String() == "shift+up":
642		if m.sidebarScrollOffset > 0 {
643			m.sidebarScrollOffset--
644		}
645		return m, nil
646
647	case msg.String() == "shift+down":
648		// sidebarTotalLines is calculated during render, but we need to constrain here
649		// For now, just increment - render will constrain to valid range
650		m.sidebarScrollOffset++
651		return m, nil
652
653	case msg.String() == "shift+home":
654		m.sidebarScrollOffset = 0
655		return m, nil
656	}
657
658	// Pass other keys to viewport for scrolling
659	var cmd tea.Cmd
660	m.viewport, cmd = m.viewport.Update(msg)
661
662	return m, cmd
663}
664
665func (m Model) handleMouseInFocus(msg tea.MouseMsg) (tea.Model, tea.Cmd) {
666	// Only handle mouse wheel events
667	if msg.Type != tea.MouseWheelUp && msg.Type != tea.MouseWheelDown {
668		// Pass other mouse events to viewport
669		var cmd tea.Cmd
670		m.viewport, cmd = m.viewport.Update(msg)
671		return m, cmd
672	}
673
674	// Calculate sidebar width (same calculation as in rendering)
675	sidebarWidth := (m.width * 33) / 100
676
677	// Check if mouse is over sidebar (X coordinate < sidebarWidth)
678	if msg.X < sidebarWidth {
679		// Scroll sidebar
680		if msg.Type == tea.MouseWheelUp {
681			if m.sidebarScrollOffset > 0 {
682				m.sidebarScrollOffset--
683			}
684		} else if msg.Type == tea.MouseWheelDown {
685			m.sidebarScrollOffset++
686		}
687		return m, nil
688	}
689
690	// Mouse is over conversation - pass to viewport
691	var cmd tea.Cmd
692	m.viewport, cmd = m.viewport.Update(msg)
693	return m, cmd
694}
695
696func (m Model) handleInputKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
697	switch {
698	case key.Matches(msg, keys.Escape):
699		m.resetInput()
700		m.pendingProvider = ""
701		m.err = nil
702		return m, nil
703
704	case key.Matches(msg, keys.Enter):
705		value := strings.TrimSpace(m.input.Value())
706
707		// Allow empty values for optional fields (provider selection)
708		// but block for required fields (handled per-mode)
709
710		var cmd tea.Cmd
711
712		switch m.input.Mode() {
713		case InputModeBroadcast:
714			if value == "" {
715				m.input.Reset()
716				return m, nil
717			}
718			// Add to history before sending
719			m.input.AddToHistory(value)
720			m.input.Reset()
721			// Mark all running myses as loading
722			myses := m.commander.ListMyses()
723			for _, mysis := range myses {
724				if mysis.State() == core.MysisStateRunning {
725					m.loadingSet[mysis.ID()] = true
726				}
727			}
728			m.netIndicator.SetActivity(NetActivityLLM)
729			m.sending = true
730			m.sendingMode = InputModeBroadcast
731			// Use Broadcast to properly set source='broadcast'
732			cmd = m.broadcastAsync(value)
733
734		case InputModeMessage:
735			// Add to history before sending
736			m.input.AddToHistory(value)
737			targetID := m.input.TargetID() // Save targetID BEFORE reset
738			m.input.Reset()                // Clear input immediately after saving targetID
739			m.loadingSet[targetID] = true
740			m.netIndicator.SetActivity(NetActivityLLM)
741			// Note: m.sending NOT set here - SendMessageAsync returns immediately
742			// Network indicator shows activity, but input is ready for next message
743			cmd = m.sendMessageAsync(targetID, value)
744			// Don't call loadMysisLogs() here - message storage now happens instantly
745			// and EventMysisMessage will trigger the refresh via handleEvent()
746
747		case InputModeNewMysis:
748			// Multi-stage flow: name → provider
749			switch m.inputStage {
750			case InputStageName:
751				// Name is required
752				if value == "" {
753					m.err = fmt.Errorf("name cannot be empty")
754					return m, nil
755				}
756				m.pendingMysisName = value
757				m.inputStage = InputStageProvider
758				m.input.textInput.SetValue("") // Clear input but keep mode
759				m.input.textInput.Placeholder = fmt.Sprintf("Provider (empty for default: %s)...", m.config.Swarm.DefaultProvider)
760				return m, nil
761
762			case InputStageProvider:
763				// Provider is optional - use default if empty
764				provider := value
765				if provider == "" {
766					provider = m.config.Swarm.DefaultProvider
767				}
768
769				// Validate provider exists
770				if _, ok := m.config.Providers[provider]; !ok {
771					// Debug: show available providers
772					var available []string
773					for p := range m.config.Providers {
774						available = append(available, p)
775					}
776					m.err = fmt.Errorf("provider '%s' not found. Available: %v", provider, available)
777					m.resetInput()
778					m.refreshMysisList()
779					return m, nil
780				}
781
782				// Create mysis with selected provider
783				mysis, err := m.commander.CreateMysis(m.pendingMysisName, provider)
784				if err == nil {
785					// Auto-start newly created myses
786					m.err = m.commander.StartMysis(mysis.ID())
787				} else {
788					m.err = err
789				}
790				m.resetInput()
791				m.refreshMysisList()
792				return m, nil
793
794			default:
795				// Safety: reset if in unexpected state
796				m.err = fmt.Errorf("unexpected input stage (%d), resetting", m.inputStage)
797				m.resetInput()
798				return m, nil
799			}
800
801		case InputModeConfigProvider:
802			// Validate provider exists in config
803			if _, ok := m.config.Providers[value]; !ok {
804				var available []string
805				for p := range m.config.Providers {
806					available = append(available, p)
807				}
808				m.err = fmt.Errorf("provider '%s' not found. Available: %v", value, available)
809				m.input.Reset()
810				return m, nil
811			}
812			m.pendingProvider = value
813			m.input.SetMode(InputModeConfigModel, m.input.TargetID())
814			return m, m.input.Focus()
815
816		case InputModeConfigModel:
817			m.err = m.commander.ConfigureMysis(m.input.TargetID(), m.pendingProvider, value)
818			m.pendingProvider = ""
819		}
820
821		m.input.Reset()
822		return m, cmd
823	}
824
825	// Pass to text input
826	var cmd tea.Cmd
827	m.input, cmd = m.input.Update(msg)
828	return m, cmd
829}
830
831// sendMessageAsync sends a message to a mysis asynchronously.
832func (m Model) sendMessageAsync(mysisID, content string) tea.Cmd {
833	return func() tea.Msg {
834		// Use async version to clear input immediately when message is sent,
835		// not when LLM completes processing
836		err := m.commander.SendMessageAsync(mysisID, content)
837		return sendMessageResult{mysisID: mysisID, err: err}
838	}
839}
840
841type broadcastResult struct {
842	err error
843}
844
845func (m Model) broadcastAsync(content string) tea.Cmd {
846	return func() tea.Msg {
847		err := m.commander.Broadcast(content)
848		return broadcastResult{err: err}
849	}
850}
851
852func (m *Model) handleEvent(event core.Event) {
853	switch event.Type {
854	case core.EventMysisCreated, core.EventMysisDeleted, core.EventMysisStateChanged, core.EventMysisConfigChanged:
855		m.refreshMysisList()
856
857	case core.EventMysisResponse, core.EventMysisMessage:
858		// Refresh dashboard to update last message
859		m.refreshMysisList()
860		// Refresh tick in case tool results updated server tick
861		m.refreshTick()
862		if m.view == ViewFocus && event.MysisID == m.focusID {
863			m.loadMysisLogs()
864		}
865
866	case core.EventBroadcast:
867		// Refresh swarm message history
868		m.refreshSwarmMessages()
869
870	case core.EventNetworkLLM:
871		m.activeNetworkOps++
872		m.netIndicator.SetActivity(NetActivityLLM)
873
874	case core.EventNetworkMCP:
875		m.activeNetworkOps++
876		m.netIndicator.SetActivity(NetActivityMCP)
877
878	case core.EventNetworkIdle:
879		// Decrement active operations counter
880		m.activeNetworkOps--
881		if m.activeNetworkOps < 0 {
882			m.activeNetworkOps = 0 // Safety: prevent negative counts
883		}
884		// Only go idle if no active network operations
885		if m.activeNetworkOps == 0 {
886			m.netIndicator.SetActivity(NetActivityIdle)
887		}
888		// Refresh tick when network goes idle (tool calls completed)
889		m.refreshTick()
890
891	case core.EventMysisError:
892		if event.Error != nil {
893			if strings.Contains(strings.ToLower(event.Error.Error), "provider chat") {
894				m.recordProviderError(event.Timestamp)
895			}
896		}
897	}
898
899	// Clear error on successful events
900	m.err = nil
901}
902
903func (m *Model) recordProviderError(ts time.Time) {
904	if ts.IsZero() {
905		ts = time.Now()
906	}
907	m.pruneProviderErrors(ts)
908	m.providerErrorTimes = append(m.providerErrorTimes, ts)
909}
910
911func (m *Model) pruneProviderErrors(now time.Time) {
912	cutoff := now.Add(-providerErrorWindow)
913	filtered := m.providerErrorTimes[:0]
914	for _, t := range m.providerErrorTimes {
915		if t.After(cutoff) {
916			filtered = append(filtered, t)
917		}
918	}
919	m.providerErrorTimes = filtered
920}
921
922func (m *Model) refreshMysisList() {
923	myses := m.commander.ListMyses()
924	m.myses = make([]MysisInfo, len(myses))
925	for i, mysis := range myses {
926		info := MysisInfoFromCore(mysis)
927
928		if info.AccountUsername == "" {
929			if acc, err := m.store.GetAccountByMysisID(info.ID); err == nil && acc != nil {
930				info.AccountUsername = acc.Username
931			}
932		}
933
934		// Fetch recent memories for message row formatting (5-10 messages to check priority)
935		memories, err := m.store.GetRecentMemories(mysis.ID(), 10)
936		if err == nil && len(memories) > 0 {
937			info.RecentMemories = memories
938			// Keep LastMessage and LastMessageAt for backward compatibility
939			info.LastMessage = memories[0].Content
940			info.LastMessageAt = memories[0].CreatedAt
941		}
942
943		m.myses[i] = info
944	}
945
946	// Sort by creation time (oldest first)
947	sort.Slice(m.myses, func(i, j int) bool {
948		return m.myses[i].CreatedAt.Before(m.myses[j].CreatedAt)
949	})
950}
951
952func (m *Model) refreshSwarmMessages() {
953	broadcasts, err := m.store.GetRecentBroadcasts(10)
954	if err != nil {
955		m.swarmMessages = nil
956		return
957	}
958
959	m.swarmMessages = make([]SwarmMessage, len(broadcasts))
960	for i, b := range broadcasts {
961		m.swarmMessages[i] = SwarmMessage{
962			SenderID:  b.SenderID,
963			Content:   b.Content,
964			CreatedAt: b.CreatedAt,
965		}
966	}
967}
968
969// refreshTick updates the currentTick field from the Commander's aggregate tick.
970func (m *Model) refreshTick() {
971	m.currentTick = m.commander.AggregateTick()
972}
973
974func (m *Model) loadMysisLogs() {
975	if m.focusID == "" {
976		m.logs = nil
977		m.viewport.SetContent("")
978		return
979	}
980
981	memories, err := m.store.GetRecentMemories(m.focusID, MaxConversationMessages)
982	if err != nil {
983		m.err = err
984		return
985	}
986
987	// Filter out broadcast and system messages from conversation log
988	var filteredLogs []LogEntry
989	for _, mem := range memories {
990		// Skip broadcast messages (both sent and received)
991		if mem.Source == store.MemorySourceBroadcast {
992			continue
993		}
994		// Skip system messages (system prompts)
995		if mem.Role == store.MemoryRoleSystem {
996			continue
997		}
998		senderName := m.mysisNameByID(mem.SenderID)
999		filteredLogs = append(filteredLogs, LogEntryFromMemory(mem, m.focusID, senderName))
1000	}
1001
1002	// Limit to MaxConversationMessages
1003	if len(filteredLogs) > MaxConversationMessages {
1004		filteredLogs = filteredLogs[len(filteredLogs)-MaxConversationMessages:]
1005	}
1006
1007	m.logs = filteredLogs
1008
1009	m.updateViewportContent()
1010}
1011
1012// updateViewportContent renders log entries and sets viewport content.
1013// Smart auto-scroll: if user is at bottom when content updates, stay at bottom.
1014func (m *Model) updateViewportContent() {
1015	if len(m.logs) == 0 {
1016		m.viewport.SetContent(dimmedStyle.Render("No conversation history."))
1017		return
1018	}
1019
1020	// Remember if user was at bottom before updating content
1021	wasAtBottom := m.viewport.AtBottom()
1022
1023	// Two-column layout: Game State Sidebar | Conversation Log
1024	// Sidebar takes 33% of terminal width (multiply first to avoid precision loss)
1025	sidebarWidth := (m.width * 33) / 100
1026	const columnGap = 3 // space + │ + space
1027	conversationWidth := m.width - sidebarWidth - columnGap
1028
1029	// Content width for conversation log (accounting for scrollbar)
1030	// No borders on conversation log, just scrollbar
1031	panelContentWidth := conversationWidth - 2 // -2 for scrollbar
1032
1033	var lines []string
1034	// Render logs in chronological order (oldest first, newest last)
1035	// Bottom of viewport shows newest messages (normal chat behavior)
1036	for i := 0; i < len(m.logs); i++ {
1037		entryLines := renderLogEntryImpl(m.logs[i], panelContentWidth, m.verboseJSON, m.currentTick)
1038		lines = append(lines, entryLines...)
1039	}
1040
1041	content := strings.Join(lines, "\n")
1042	m.viewport.SetContent(content)
1043	m.viewportTotalLines = len(lines) // Track total lines
1044
1045	// Smart auto-scroll: if user was at bottom, keep them at bottom after content update
1046	// This prevents jarring jumps when user has manually scrolled up to read history
1047	if wasAtBottom {
1048		m.viewport.GotoBottom()
1049	}
1050}
1051
1052func (m Model) mysisByID(id string) MysisInfo {
1053	for _, mysis := range m.myses {
1054		if mysis.ID == id {
1055			return mysis
1056		}
1057	}
1058	return MysisInfo{ID: id, Name: "Unknown", State: "unknown"}
1059}
1060
1061func (m Model) mysisNameByID(id string) string {
1062	if id == "" {
1063		return ""
1064	}
1065	for _, mysis := range m.myses {
1066		if mysis.ID == id {
1067			return mysis.Name
1068		}
1069	}
1070	return ""
1071}
1072
1073func (m Model) focusPosition(focusID string) (int, int) {
1074	total := len(m.myses)
1075	if focusID == "" || total == 0 {
1076		return 0, total
1077	}
1078	for i, mysis := range m.myses {
1079		if mysis.ID == focusID {
1080			return i + 1, total
1081		}
1082	}
1083	return 0, total
1084}
1085
1086// resetInput resets input state and clears multi-stage flow.
1087func (m *Model) resetInput() {
1088	m.input.Reset()
1089	m.inputStage = InputStageName
1090	m.pendingMysisName = ""
1091	m.pendingMysisProvider = ""
1092}
1093
1094type refreshMysesMsg struct{}
1095
1096// sendMessageResult is returned when an async message send completes.
1097type sendMessageResult struct {
1098	mysisID string
1099	err     error
1100}
1101
1102func (m Model) refreshMyses() tea.Cmd {
1103	return func() tea.Msg {
1104		return refreshMysesMsg{}
1105	}
1106}
1107
1108func (m Model) listenForEvents() tea.Cmd {
1109	return func() tea.Msg {
1110		event, ok := <-m.eventCh
1111		if !ok {
1112			return nil
1113		}
1114		return EventMsg{Event: event}
1115	}
1116}
1117
1118// Key bindings
1119var keys = struct {
1120	Quit          key.Binding
1121	Help          key.Binding
1122	Escape        key.Binding
1123	Enter         key.Binding
1124	Tab           key.Binding
1125	ShiftTab      key.Binding
1126	Up            key.Binding
1127	Down          key.Binding
1128	NewMysis      key.Binding
1129	Delete        key.Binding
1130	Relaunch      key.Binding
1131	Stop          key.Binding
1132	Broadcast     key.Binding
1133	Message       key.Binding
1134	Configure     key.Binding
1135	End           key.Binding
1136	VerboseToggle key.Binding
1137}{
1138	Quit:          key.NewBinding(key.WithKeys("q", "ctrl+c")),
1139	Help:          key.NewBinding(key.WithKeys("?")),
1140	Escape:        key.NewBinding(key.WithKeys("esc")),
1141	Enter:         key.NewBinding(key.WithKeys("enter")),
1142	Tab:           key.NewBinding(key.WithKeys("tab")),
1143	ShiftTab:      key.NewBinding(key.WithKeys("shift+tab")),
1144	Up:            key.NewBinding(key.WithKeys("up", "k")),
1145	Down:          key.NewBinding(key.WithKeys("down", "j")),
1146	NewMysis:      key.NewBinding(key.WithKeys("n")),
1147	Delete:        key.NewBinding(key.WithKeys("d")),
1148	Relaunch:      key.NewBinding(key.WithKeys("r")),
1149	Stop:          key.NewBinding(key.WithKeys("s")),
1150	Broadcast:     key.NewBinding(key.WithKeys("b")),
1151	Message:       key.NewBinding(key.WithKeys("m")),
1152	Configure:     key.NewBinding(key.WithKeys("c")),
1153	End:           key.NewBinding(key.WithKeys("end", "G")),
1154	VerboseToggle: key.NewBinding(key.WithKeys("v")),
1155}