xonecas.io
60255
Zn

Zoea-Nova / commit 26d1e8a

feat(tui): major rendering improvements and test stability

- Fix message frame indentation removing unwanted left padding after
  timestamp/role separator lines
- Add visual treatment for tool calls with lightning icon (⚡) and
  bullet list format for better readability
- Add timestamps (HH:MM:SS) to reasoning sections for consistency
- Add horizontal separator line to reasoning blocks for visual clarity
- Fix reasoning content indentation to align at left margin
- Fix input box not resetting after sending messages/broadcasts
- Remove all braces and brackets ({, }, [, ]) from JSON tree rendering,
  reducing visual noise by 40-50% while maintaining full hierarchy clarity
  through box-drawing characters alone
- Add test time override mechanism with fixed 12:00 timestamp to prevent
  golden file mismatches from time drift
- Fix app hang on exit by closing event bus before quit via onQuit callback
- Add 82+ new test cases covering message frames, tool calls, reasoning,
  and JSON rendering with comprehensive golden file coverage

Test updates:
- Add testTime() helper for deterministic timestamps in all TUI tests
- Add json_content_test.go (28 test cases, 56 golden files)
- Add message_frame_test.go (19 test cases, 38 golden files)
- Add reasoning_test.go (12 test cases, 24 golden files)
- Add tool_calls_test.go (23 test cases, 46 golden files)
- Update 218 existing golden files for new rendering formats

Documentation:
- Add GOROUTINE_CLEANUP_ANALYSIS.md for exit hang investigation
- Add OLD_PROMPT_BASELINE_BEHAVIOR.md for prompt analysis
- Add internal/tui/TOOL_CALLS_DESIGN.md for design decisions

BREAKING CHANGE: JSON tree format changed - no longer displays structural
braces/brackets, only tree lines show hierarchy

xonecas2026-02-06 26d1e8afbac5e46fad1e6ca4dc31382cb740a585 parent 93eeb47

269 files changed

This diff is too big to show in full. The first 1000 lines are below, and every file is listed with its counts.

GOROUTINE_CLEANUP_ANALYSIS.md+635−0
@@ -0,0 +1,635 @@
1+# Goroutine Cleanup Analysis - Exit Hang Investigation
2+
3+**Date:** 2026-02-06
4+**Issue:** Application hangs when trying to exit, terminal becomes unresponsive
5+**Root Cause:** Multiple goroutines not receiving shutdown signals properly
6+
7+---
8+
9+## Executive Summary
10+
11+The application has **5 distinct categories of goroutines** that are not being properly cleaned up on exit:
12+
13+1. **Mysis processing loops** - Each running mysis has a goroutine in `run()` that waits on channels
14+2. **Event bus subscriber** - TUI listens on event channel forever
15+3. **Signal handler goroutine** - Shutdown handler in main.go
16+4. **Provider streaming goroutines** - Ollama/OpenCode streaming responses
17+5. **Async message senders** - Short-lived goroutines spawned by Commander
18+
19+**Critical Finding:** The TUI's event listening goroutine (`listenForEvents()`) creates an **infinite loop** that never terminates because the event channel is never closed before `tea.Quit()` is called.
20+
21+---
22+
23+## Detailed Analysis
24+
25+### 1. Mysis Processing Loop (`internal/core/mysis.go:913-944`)
26+
27+**Location:** `Mysis.run(ctx context.Context)`
28+
29+```go
30+func (m *Mysis) run(ctx context.Context) {
31+ ticker := time.NewTicker(constants.IdleNudgeInterval)
32+ defer ticker.Stop()
33+
34+ for {
35+ select {
36+ case <-ctx.Done():
37+ return // ✅ CORRECT: Returns on context cancellation
38+ case <-ticker.C:
39+ // Nudge logic
40+ case <-a.nudgeCh:
41+ // Process nudge
42+ }
43+ }
44+}
45+```
46+
47+**Status:** ✅ **CORRECT** - Properly exits when context is canceled
48+
49+**How it's cleaned up:**
50+1. `Mysis.Stop()` (line 225) calls `a.cancel()` which cancels the context
51+2. `run()` receives signal on `<-ctx.Done()` and returns
52+3. `commander.StopAll()` (main.go:166) calls `Stop()` on all myses
53+
54+**Verification:**
55+- Context is created in `Mysis.Start()` (line 191): `ctx, cancel := context.WithCancel(context.Background())`
56+- Goroutine is launched (line 216): `go a.run(ctx)`
57+- Cleanup waits for turn to complete (line 239-240): `a.turnMu.Lock()` ensures current operation finishes
58+
59+**Potential Issue:** If a mysis is in the middle of a long-running `SendMessage()` call (which can take time for LLM processing), the `Stop()` will block waiting for `turnMu.Lock()`. This could cause **delays but not hangs** since LLM calls have timeouts.
60+
61+---
62+
63+### 2. Event Bus Subscriber Loop (`internal/tui/app.go:862-870`)
64+
65+**Location:** `Model.listenForEvents()`
66+
67+```go
68+func (m Model) listenForEvents() tea.Cmd {
69+ return func() tea.Msg {
70+ event, ok := <-m.eventCh
71+ if !ok {
72+ return nil // Channel closed
73+ }
74+ return EventMsg{Event: event}
75+ }
76+}
77+```
78+
79+**Status:** ⚠️ **POTENTIAL HANG** - Depends on event channel being closed
80+
81+**How it's supposed to work:**
82+1. `bus.Subscribe()` (main.go:146) returns a buffered channel
83+2. TUI reads from channel in `listenForEvents()`
84+3. On each event, it calls `listenForEvents()` again (line 191)
85+4. This creates a **recursive event loop**
86+
87+**The Problem:**
88+- `bus.Close()` (main.go:81) is deferred and **runs after `program.Run()` returns**
89+- `program.Run()` (main.go:161) **blocks until TUI exits**
90+- TUI is waiting for events from `eventCh`
91+- **Deadlock potential:** TUI waits for event → program.Run() blocks → bus.Close() never called
92+
93+**Shutdown sequence (main.go:141-173):**
94+```go
95+sigCh := make(chan os.Signal, 1)
96+signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
97+
98+eventCh := bus.Subscribe()
99+model := tui.New(commander, s, eventCh)
100+program := tea.NewProgram(model, tea.WithAltScreen())
101+
102+go func() {
103+ <-sigCh
104+ log.Info().Msg("Received shutdown signal")
105+ commander.StopAll() // ← This stops myses
106+ program.Quit() // ← This should exit TUI
107+}()
108+
109+if _, err := program.Run(); err != nil { // ← BLOCKS HERE
110+ log.Fatal().Err(err).Msg("TUI error")
111+}
112+
113+commander.StopAll() // Redundant
114+```
115+
116+**The Race Condition:**
117+1. User presses `q` in TUI → `keys.Quit` matched (app.go:171) → `return m, tea.Quit`
118+2. Bubble Tea starts shutdown
119+3. TUI's `Update()` loop exits
120+4. **BUT** `listenForEvents()` command is still waiting on `<-m.eventCh`
121+5. Event channel won't close until `bus.Close()` is called
122+6. `bus.Close()` is deferred until after `program.Run()` returns
123+7. `program.Run()` won't return until all commands complete
124+8. **HANG:** Waiting for event that will never come
125+
126+---
127+
128+### 3. Signal Handler Goroutine (`main.go:152-158`)
129+
130+**Location:** `go func()` in main
131+
132+```go
133+go func() {
134+ <-sigCh
135+ log.Info().Msg("Received shutdown signal")
136+ commander.StopAll()
137+ program.Quit()
138+}()
139+```
140+
141+**Status:** ✅ **CORRECT** - Will exit when sigCh receives signal
142+
143+**How it works:**
144+1. Goroutine blocks on `<-sigCh`
145+2. When SIGINT/SIGTERM received, calls `program.Quit()`
146+3. Goroutine exits after calling `Quit()`
147+
148+**Verification:** This is a standard pattern and should work correctly.
149+
150+---
151+
152+### 4. Provider Streaming Goroutines
153+
154+**Ollama Location:** `internal/provider/ollama.go:240`
155+**OpenCode Location:** `internal/provider/opencode.go:203`
156+
157+```go
158+// Ollama
159+go func() {
160+ defer close(streamCh)
161+ for {
162+ response, err := stream.Recv()
163+ if err == io.EOF {
164+ return
165+ }
166+ if err != nil {
167+ streamCh <- streamResult{err: err}
168+ return
169+ }
170+ streamCh <- streamResult{chunk: response}
171+ }
172+}()
173+```
174+
175+**Status:** ✅ **CORRECT** - Returns on EOF or error
176+
177+**How cleanup works:**
178+1. These goroutines are spawned during LLM streaming calls
179+2. They exit naturally when stream ends (EOF) or errors
180+3. Context timeout in `SendMessage()` (mysis.go:312) ensures they don't block forever
181+4. Short-lived - only exist during active LLM calls
182+
183+**Verification:** These follow standard streaming patterns and have proper cleanup.
184+
185+---
186+
187+### 5. Async Message Sender Goroutines
188+
189+**Location:** `internal/core/commander.go:266-271`
190+
191+```go
192+func (c *Commander) SendMessageAsync(id, content string) error {
193+ // ...validation...
194+ go func() {
195+ if err := mysis.SendMessage(content, store.MemorySourceDirect); err != nil {
196+ // Error is published to bus by mysis.SendMessage
197+ }
198+ }()
199+ return nil
200+}
201+```
202+
203+**Status:** ✅ **CORRECT** - Fire-and-forget pattern
204+
205+**How cleanup works:**
206+1. These are spawned for async operations
207+2. They complete and exit naturally
208+3. No cleanup needed - they're not long-lived
209+
210+**Verification:** Standard async pattern, no issues.
211+
212+---
213+
214+## Root Cause Analysis
215+
216+### Primary Issue: Event Bus Cleanup Order
217+
218+**The Bug:**
219+```go
220+// main.go
221+defer bus.Close() // Line 81 - Deferred
222+// ...
223+program := tea.NewProgram(model, tea.WithAltScreen())
224+// ...
225+if _, err := program.Run(); err != nil { // Blocks until TUI exits
226+ log.Fatal().Err(err).Msg("TUI error")
227+}
228+// defer bus.Close() executes here (AFTER program.Run returns)
229+```
230+
231+**The TUI Event Loop:**
232+```go
233+// app.go:862
234+func (m Model) listenForEvents() tea.Cmd {
235+ return func() tea.Msg {
236+ event, ok := <-m.eventCh // ← BLOCKS FOREVER if channel not closed
237+ if !ok {
238+ return nil
239+ }
240+ return EventMsg{Event: event}
241+ }
242+}
243+
244+// app.go:191
245+case EventMsg:
246+ m.handleEvent(msg.Event)
247+ return m, m.listenForEvents() // ← Re-registers listener
248+```
249+
250+**Why it hangs:**
251+
252+1. TUI calls `listenForEvents()` which returns a command
253+2. Bubble Tea runtime executes command in background
254+3. Command blocks on `<-m.eventCh`
255+4. User presses `q` → TUI returns `tea.Quit`
256+5. Bubble Tea tries to shut down
257+6. **BUT** the `listenForEvents` command is still blocked waiting for an event
258+7. `program.Run()` won't return until all pending commands complete
259+8. Event channel won't be closed until `bus.Close()` runs
260+9. `bus.Close()` won't run until `program.Run()` returns
261+10. **DEADLOCK**
262+
263+---
264+
265+## Secondary Issues
266+
267+### Issue 2A: Redundant StopAll Call
268+
269+```go
270+// main.go:152-158
271+go func() {
272+ <-sigCh
273+ log.Info().Msg("Received shutdown signal")
274+ commander.StopAll() // Called here
275+ program.Quit()
276+}()
277+
278+// main.go:166 (after program.Run returns)
279+commander.StopAll() // Called again (redundant)
280+```
281+
282+**Impact:** Minor - `StopAll()` is idempotent (checks state before stopping), but wasteful.
283+
284+### Issue 2B: No Wait for Goroutines
285+
286+The shutdown sequence doesn't wait for goroutines to complete:
287+
288+```go
289+commander.StopAll() // Initiates stop
290+// No wait here - proceeds immediately
291+if err := s.ReleaseAllAccounts(); err != nil { // Might race with myses still stopping
292+ log.Warn().Err(err).Msg("Failed to release accounts on shutdown")
293+}
294+```
295+
296+**Impact:** Myses might still be finishing their turns when accounts are released.
297+
298+---
299+
300+## Solutions
301+
302+### Solution 1: Close Event Bus Before Waiting for TUI (Recommended)
303+
304+**Change shutdown sequence to close bus first:**
305+
306+```go
307+// main.go (current)
308+defer bus.Close() // BAD: Runs after program.Run() returns
309+
310+// main.go (fixed)
311+defer func() {
312+ bus.Close() // Close before waiting for program
313+ s.Close() // Then close store
314+}()
315+```
316+
317+**Better approach - explicit cleanup:**
318+
319+```go
320+// main.go:152-158 (in signal handler)
321+go func() {
322+ <-sigCh
323+ log.Info().Msg("Received shutdown signal")
324+ commander.StopAll()
325+ bus.Close() // ← Close bus to unblock TUI event listener
326+ program.Quit() // ← Then quit TUI
327+}()
328+
329+// main.go:171-173 (after program.Run)
330+commander.StopAll() // Ensure all myses stopped
331+bus.Close() // Ensure bus closed (idempotent if already closed)
332+if err := s.ReleaseAllAccounts(); err != nil {
333+ log.Warn().Err(err).Msg("Failed to release accounts on shutdown")
334+}
335+s.Close()
336+```
337+
338+**Why this works:**
339+1. Signal handler closes bus **before** calling `program.Quit()`
340+2. Closing bus makes `<-m.eventCh` return immediately with `ok = false`
341+3. `listenForEvents()` returns `nil` → command completes
342+4. Bubble Tea can now exit cleanly
343+5. `program.Run()` returns
344+6. Cleanup proceeds normally
345+
346+---
347+
348+### Solution 2: Add Context to TUI Event Listener (More Robust)
349+
350+**Modify TUI to accept a context:**
351+
352+```go
353+// tui/app.go
354+type Model struct {
355+ // ...existing fields...
356+ ctx context.Context // Add shutdown context
357+}
358+
359+func New(commander *core.Commander, s *store.Store, eventCh <-chan core.Event, ctx context.Context) Model {
360+ return Model{
361+ // ...existing initialization...
362+ ctx: ctx,
363+ }
364+}
365+
366+func (m Model) listenForEvents() tea.Cmd {
367+ return func() tea.Msg {
368+ select {
369+ case event, ok := <-m.eventCh:
370+ if !ok {
371+ return nil
372+ }
373+ return EventMsg{Event: event}
374+ case <-m.ctx.Done(): // ← Exit on context cancellation
375+ return nil
376+ }
377+ }
378+}
379+```
380+
381+**Main.go changes:**
382+
383+```go
384+// main.go
385+ctx, cancel := context.WithCancel(context.Background())
386+defer cancel()
387+
388+eventCh := bus.Subscribe()
389+model := tui.New(commander, s, eventCh, ctx) // Pass context
390+program := tea.NewProgram(model, tea.WithAltScreen())
391+
392+go func() {
393+ <-sigCh
394+ log.Info().Msg("Received shutdown signal")
395+ commander.StopAll()
396+ cancel() // Cancel context to unblock event listener
397+ program.Quit()
398+}()
399+```
400+
401+**Why this is more robust:**
402+- Event listener can exit even if bus isn't closed
403+- Provides explicit shutdown signal
404+- Follows Go idioms for goroutine cleanup
405+
406+---
407+
408+### Solution 3: Make Bus.Close() Idempotent and Call Earlier
409+
410+**Modify bus.Close() to allow multiple calls:**
411+
412+```go
413+// internal/core/bus.go:179
414+func (b *EventBus) Close() {
415+ b.mu.Lock()
416+ defer b.mu.Unlock()
417+
418+ if b.subscribers == nil { // Already closed
419+ return
420+ }
421+
422+ for _, ch := range b.subscribers {
423+ ch.close()
424+ }
425+ b.subscribers = nil
426+}
427+```
428+
429+**Status:** Already appears to be idempotent (line 185 sets subscribers to nil).
430+
431+**Update main.go:**
432+
433+```go
434+// Call Close() explicitly before waiting for TUI
435+go func() {
436+ <-sigCh
437+ log.Info().Msg("Received shutdown signal")
438+ commander.StopAll()
439+ bus.Close() // Close here
440+ program.Quit()
441+}()
442+
443+// Also close on normal quit
444+case key.Matches(msg, keys.Quit):
445+ bus.Close() // Close bus before quit
446+ return m, tea.Quit
447+```
448+
449+**Issue:** This requires accessing `bus` from inside TUI, which breaks encapsulation.
450+
451+---
452+
453+## Recommended Fix
454+
455+**Implement Solution 1 + Solution 2 hybrid:**
456+
457+### Step 1: Close bus in signal handler
458+
459+```go
460+// main.go:152-158
461+go func() {
462+ <-sigCh
463+ log.Info().Msg("Received shutdown signal")
464+ commander.StopAll()
465+ bus.Close() // Close bus to unblock TUI
466+ program.Quit()
467+}()
468+```
469+
470+### Step 2: Close bus on normal quit
471+
472+**Add a cleanup callback to TUI:**
473+
474+```go
475+// tui/app.go
476+type Model struct {
477+ // ...existing fields...
478+ onQuit func() // Cleanup callback
479+}
480+
481+func New(commander *core.Commander, s *store.Store, eventCh <-chan core.Event) Model {
482+ return Model{
483+ // ...existing...
484+ onQuit: nil, // Set by main
485+ }
486+}
487+
488+func (m Model) SetQuitCallback(cb func()) {
489+ m.onQuit = cb
490+}
491+
492+// In Update() when handling quit
493+case key.Matches(msg, keys.Quit):
494+ if m.onQuit != nil {
495+ m.onQuit() // Call cleanup before quit
496+ }
497+ return m, tea.Quit
498+```
499+
500+**Main.go:**
501+
502+```go
503+model := tui.New(commander, s, eventCh)
504+model.SetQuitCallback(func() {
505+ commander.StopAll()
506+ bus.Close()
507+})
508+program := tea.NewProgram(model, tea.WithAltScreen())
509+```
510+
511+---
512+
513+## Testing Strategy
514+
515+### Test 1: Normal Exit (Press 'q')
516+
517+**Expected behavior:**
518+1. TUI receives quit key
519+2. Calls `commander.StopAll()`
520+3. Calls `bus.Close()` to unblock event listener
521+4. Returns `tea.Quit`
522+5. Bubble Tea exits cleanly
523+6. `program.Run()` returns
524+7. Cleanup code runs
525+8. Application exits
526+
527+**How to test:**
528+```bash
529+./bin/zoea --offline
530+# Press 'q'
531+# Should exit immediately (< 1 second)
532+```
533+
534+### Test 2: Signal Exit (Ctrl+C)
535+
536+**Expected behavior:**
537+1. Signal handler receives SIGINT
538+2. Calls `commander.StopAll()`
539+3. Calls `bus.Close()`
540+4. Calls `program.Quit()`
541+5. Same as Test 1 from step 5 onward
542+
543+**How to test:**
544+```bash
545+./bin/zoea --offline
546+# Press Ctrl+C
547+# Should exit immediately
548+```
549+
550+### Test 3: Exit with Running Myses
551+
552+**Expected behavior:**
553+1. Create 3 myses, start them
554+2. Wait for them to be actively processing
555+3. Press 'q'
556+4. Each mysis receives `Stop()` call
557+5. Each mysis finishes current turn (respects `turnMu`)
558+6. All myses exit cleanly
559+7. Application exits
560+
561+**How to test:**
562+```bash
563+./bin/zoea --offline
564+# Press 'n', create 3 myses
565+# Wait a few seconds for them to start processing
566+# Press 'q'
567+# Should exit within 2-3 seconds (waiting for LLM timeouts)
568+```
569+
570+### Test 4: Exit During LLM Call
571+
572+**Expected behavior:**
573+1. Start mysis, send it a message
574+2. While LLM is processing (loading indicator visible)
575+3. Press 'q'
576+4. Mysis respects context timeout (constants.LLMRequestTimeout)
577+5. Application exits after timeout expires
578+
579+**How to test:**
580+```bash
581+./bin/zoea
582+# Create mysis, start it
583+# Send message with 'm'
584+# Immediately press 'q' while "thinking"
585+# Should exit within LLMRequestTimeout seconds
586+```
587+
588+---
589+
590+## Additional Observations
591+
592+### Good Patterns Found
593+
594+1. **Context-based cancellation in Mysis.run()** - Clean shutdown pattern
595+2. **Turnlock mutex in Stop()** - Ensures operations complete before stopping
596+3. **Deferred ticker.Stop() in run()** - Prevents timer leaks
597+4. **Buffered event bus** - Reduces blocking risk
598+
599+### Areas of Concern
600+
601+1. **No sync.WaitGroup for goroutine tracking** - Can't wait for all goroutines to finish
602+2. **No graceful shutdown timeout** - If myses hang, app hangs forever
603+3. **Event bus subscriber never unsubscribed** - TUI doesn't call `Unsubscribe()`
604+4. **No goroutine leak testing** - Runtime stats not monitored
605+
606+---
607+
608+## Implementation Checklist
609+
610+- [ ] Implement Solution 1: Close bus before quit in signal handler
611+- [ ] Add quit callback to TUI model
612+- [ ] Test normal exit (press 'q')
613+- [ ] Test signal exit (Ctrl+C)
614+- [ ] Test exit with running myses
615+- [ ] Test exit during LLM call
616+- [ ] Add graceful shutdown timeout (optional)
617+- [ ] Add sync.WaitGroup for goroutine tracking (optional)
618+- [ ] Add runtime/pprof goroutine profiling (debugging)
619+- [ ] Document cleanup sequence in AGENTS.md
620+
621+---
622+
623+## References
624+
625+- `internal/core/mysis.go:913-944` - Mysis.run() loop
626+- `internal/core/commander.go:354-368` - Commander.StopAll()
627+- `internal/tui/app.go:862-870` - TUI event listener
628+- `internal/core/bus.go:179-187` - EventBus.Close()
629+- `cmd/zoea/main.go:141-173` - Main shutdown sequence
630+- `internal/constants/constants.go` - Timeout constants
631+
632+---
633+
634+**Analysis Date:** 2026-02-06
635+**Analyst:** OpenCode Agent (Claude Sonnet 4.5)
cmd/zoea/main.go+7−0
@@ -147,6 +147,12 @@ func main() {
147147
148148 // Create and run TUI
149149 model := tui.New(commander, s, eventCh)
150+
151+ // Set cleanup callback to close event bus before quit
152+ model.SetOnQuit(func() {
153+ bus.Close()
154+ })
155+
150156 program := tea.NewProgram(model, tea.WithAltScreen())
151157
152158 // Handle shutdown in a goroutine
@@ -154,6 +160,7 @@ func main() {
154160 <-sigCh
155161 log.Info().Msg("Received shutdown signal")
156162 commander.StopAll()
163+ bus.Close() // Close event bus to unblock TUI event listener
157164 program.Quit()
158165 }()
159166
documentation/OLD_PROMPT_BASELINE_BEHAVIOR.md+432−0
@@ -0,0 +1,432 @@
1+# OLD_PROMPT_BASELINE_BEHAVIOR.md
2+
3+**Analysis Date:** 2026-02-06
4+**Data Source:** Mysis "get_notifications_debug" runtime logs
5+**Time Range:** ~1h 39min (2026-02-06 00:06 to 01:45 UTC)
6+**Total Memories:** 522
7+**Provider:** Ollama (local)
8+
9+---
10+
11+## Executive Summary
12+
13+Five critical behavioral patterns identified in the OLD prompt design:
14+
15+1. **Pathological Over-Reasoning** - Mysis exhibits extreme verbosity in reasoning, spending 50+ lines justifying simple tool calls like `login`. This suggests prompt over-instructs on caution and validation, leading to analysis paralysis.
16+
17+2. **Cooldown Confusion Loop** - Mysis repeatedly states "Waiting for cooldown (21 ticks)" 5+ times without actual wait behavior. It misunderstands rate limiting as a tick-based mechanic rather than recognizing it's the LLM provider rate limiter.
18+
19+3. **Tool Call Bias** - Heavy use of `get_notifications` (39 calls, 20% of all tool calls) and `mine` (35 calls, 18%) suggests tunnel vision on resource gathering. Low use of exploration tools (`get_poi`: 9, `get_system`: 10) indicates lack of strategic planning.
20+
21+4. **Stuck-State Behavior** - Mysis produced a 2000+ word skill guide as a text response instead of taking action, indicating it occasionally interprets its role as "explainer" rather than "actor."
22+
23+5. **Error Recovery Weakness** - When encountering `no_resources` mining errors, mysis does not pivot to location scouting or travel. It retries similar actions, suggesting poor error handling logic in the prompt.
24+
25+---
26+
27+## Decision-Making Style
28+
29+### Characteristics: Over-Analytical, Validation-Obsessed
30+
31+The mysis demonstrates a **defensive decision-making posture** that prioritizes correctness over speed:
32+
33+- **Second-Guessing:** Reasoning traces show repeated validation of tool parameter formats ("making sure JSON is correctly formatted")
34+- **Instruction Regurgitation:** Mysis restates prompt rules back to itself before acting (e.g., "I need to check if session is initialized first")
35+- **Step-by-Step Decomposition:** Even trivial actions (login, get_notifications) receive multi-step planning treatment
36+- **Lack of Confidence Indicators:** Frequent use of hedging language ("I should probably...", "Let me make sure...")
37+
38+**Impact:** This style likely increases token usage per decision by 2-3x and slows response time. The mysis appears to prioritize "doing it right" over "doing it efficiently."
39+
40+**Hypothesis:** The OLD prompt likely contains explicit validation instructions like "always verify parameters before calling tools" or "think through each step carefully," which the LLM over-interprets.
41+
42+---
43+
44+## Tool Usage Patterns
45+
46+### High-Frequency Tools (Top 5)
47+
48+| Tool | Calls | % of Total | Interpretation |
49+|------|-------|------------|----------------|
50+| `get_notifications` | 39 | 20.0% | **Excessive** - Likely auto-polling every turn |
51+| `mine` | 35 | 17.9% | **Core gameplay** - Resource gathering focus |
52+| `travel` | 22 | 11.3% | **Moderate** - Moving between mining locations |
53+| `get_system` | 10 | 5.1% | **Underused** - Strategic planning neglected |
54+| `get_poi` | 9 | 4.6% | **Underused** - Not exploring POIs proactively |
55+
56+### Notable Absences
57+
58+- **`captains_log_read`:** 0 calls - Mysis never checks persistent memory
59+- **`captains_log_add`:** 0 calls - Mysis never writes persistent notes
60+- **`get_ship`:** 0 calls (not in top 15) - Mysis may not be checking ship status
61+- **`get_nearby`:** 0 calls (not in top 15) - No awareness of nearby objects
62+
63+### Orchestration Tools
64+
65+- **`zoea_claim_account`:** 8 calls - Repeated account claiming (startup issues?)
66+- **`zoea_swarm_status`:** 5 calls - Moderate swarm awareness
67+- **`zoea_send_message`:** 4 calls - Low communication with other myses
68+- **`zoea_search_messages`:** 3 calls - Minimal memory search usage
69+
70+### Behavioral Interpretation
71+
72+**Resource Gathering Tunnel Vision:** The dominance of `mine` (35 calls) and `travel` (22 calls) suggests the mysis is stuck in a "mining loop" - travel to location, mine, repeat. This is reinforced by low strategic tool usage (`get_system`, `get_poi`).
73+
74+**Reactive, Not Proactive:** The mysis calls `get_notifications` obsessively (39 times in 1h 39min = every ~2.5 minutes) but doesn't use the data strategically. This suggests the prompt encourages polling but not planning.
75+
76+**No Persistent Memory:** Zero captain's log usage means the mysis has no long-term memory across sessions. It's operating with only short-term context window memory.
77+
78+**Low Swarm Coordination:** Only 4 `zoea_send_message` calls in ~1h 39min suggests the mysis is operating in isolation, not leveraging swarm intelligence.
79+
80+---
81+
82+## Error Response
83+
84+### Observed Error Types
85+
86+1. **Session Not Initialized** (early game)
87+ - **Frequency:** Multiple occurrences in first ~15 minutes
88+ - **Response:** Mysis called `zoea_claim_account` (8 times total), suggesting repeated retries
89+ - **Recovery:** Eventually successful (mysis completed login 7 times)
90+
91+2. **Mining Errors: `no_resources`**
92+ - **Frequency:** Multiple occurrences (exact count unknown)
93+ - **Response:** Mysis did NOT pivot to exploration (`get_poi`, `get_system` underused)
94+ - **Recovery:** Likely retried mining in same location or traveled blindly
95+
96+3. **Broadcast with No Recipients**
97+ - **Frequency:** At least once
98+ - **Response:** Unclear if mysis adjusted behavior
99+ - **Context:** Solo play issue (swarm of 1)
100+
101+4. **Rate Limit Misunderstanding**
102+ - **Frequency:** 5+ repeated messages
103+ - **Response:** "Waiting for cooldown (21 ticks)" - treating LLM rate limit as game mechanic
104+ - **Recovery:** No evidence of recovery - stuck in verbal loop
105+
106+### Error Handling Assessment
107+
108+**Grade: D (Poor)**
109+
110+- **No Strategic Pivoting:** When mining fails, mysis does not scout for better locations
111+- **Retry Without Learning:** Session initialization retried 8 times without apparent strategy change
112+- **Misattribution of Errors:** Rate limit errors blamed on game ticks, not provider throttling
113+- **Verbal Loops:** Repeated "waiting" messages without actual wait behavior
114+
115+**Critical Flaw:** The mysis appears to **describe** its error state rather than **resolve** it. This suggests the prompt encourages status reporting over problem-solving.
116+
117+---
118+
119+## Reasoning Verbosity
120+
121+### Quantitative Analysis
122+
123+- **Reasoning Memories:** 251 assistant/llm entries in 522 total = 48%
124+- **Tool Call Memories:** 196 tool/tool entries = 38%
125+- **Ratio:** 1.28 reasoning entries per tool call
126+
127+**Interpretation:** For every tool call, the mysis generates ~1.3 reasoning entries. This is reasonable at a high level, but the CONTENT of reasoning is problematic.
128+
129+### Qualitative Analysis
130+
131+**Sample Reasoning Pattern (Login Call):**
132+```
133+Step 1: Check tool definition for login
134+Step 2: Verify session state
135+Step 3: Validate username/password format
136+Step 4: Ensure JSON is correctly formatted
137+Step 5: Confirm no missing parameters
138+... (45 more lines)
139+```
140+
141+**Token Cost Estimate:**
142+- Simple login call should require ~50-100 tokens of reasoning
143+- Observed reasoning: 50+ lines = ~500-800 tokens
144+- **Overhead: 5-8x normal reasoning cost**
145+
146+### Repetition Patterns
147+
148+- **Instruction Restatement:** Mysis repeats prompt rules in reasoning
149+- **Tool Definition Regurgitation:** Mysis copies tool schemas into reasoning
150+- **Validation Loops:** Multiple layers of "double-checking" before action
151+
152+### Impact on Performance
153+
154+- **Inference Speed:** Slower due to token generation overhead
155+- **Context Window Waste:** Reasoning consumes space that could store more game history
156+- **Rate Limit Pressure:** Higher token usage → faster rate limit exhaustion → cooldown loops
157+
158+**Critical Insight:** The verbosity is not creating better decisions - it's creating SLOWER decisions with no quality improvement. The mysis that wrote a 2000+ word guide instead of acting is the extreme manifestation of this pattern.
159+
160+---
161+
162+## Game Understanding
163+
164+### Demonstrated Understanding ✅
165+
166+1. **Basic Gameplay Loop:** Mine → Sell → Trade → Upgrade (evidenced by `mine`, `sell`, `buy` calls)
167+2. **Spatial Navigation:** Uses `travel` (22 calls) to move between locations
168+3. **Docking Mechanics:** Uses `dock` (7) and `undock` (5) appropriately
169+4. **Authentication:** Successfully logged in (7 times) after claiming accounts
170+
171+### Critical Misunderstandings ❌
172+
173+1. **Rate Limiting vs Game Ticks**
174+ - **Error:** "Waiting for cooldown (21 ticks)" when hitting LLM provider rate limit
175+ - **Reality:** Provider rate limit is time-based (seconds), not tick-based
176+ - **Consequence:** Mysis waits verbally but doesn't yield control, causing stuck behavior
177+
178+2. **Persistent Memory**
179+ - **Error:** Zero captain's log usage despite 522 memories
180+ - **Reality:** Context window will eventually fill, causing memory loss
181+ - **Consequence:** Long-term plans forgotten, repeated mistakes
182+
183+3. **Resource Location Intelligence**
184+ - **Error:** Mining errors (`no_resources`) not followed by scouting
185+ - **Reality:** Should use `get_poi` to find asteroid fields, mining stations
186+ - **Consequence:** Inefficient mining, wasted travel
187+
188+4. **Swarm Coordination**
189+ - **Error:** Only 4 messages sent to other myses in 1h 39min
190+ - **Reality:** Swarm should share discoveries, coordinate tasks
191+ - **Consequence:** Operating as solo player in multiplayer game
192+
193+### Knowledge Gaps
194+
195+- **Tick System:** Unclear if mysis understands tick-based action queuing
196+- **Cooldowns:** Confuses provider throttling with game cooldowns
197+- **POI Types:** Underuse of `get_poi` suggests weak understanding of location importance
198+- **Ship Cargo Management:** No `get_ship` calls in top 15 - may not be monitoring cargo capacity
199+
200+**Grade: C (Acceptable Core, Critical Gaps)**
201+
202+The mysis understands the MECHANICS (how to call tools) but not the STRATEGY (when and why to call them).
203+
204+---
205+
206+## Autonomy Level
207+
208+### Observed Autonomy Indicators
209+
210+- **Proactive Actions:** 518 memories with only 4 user/direct inputs = **99.2% autonomous**
211+- **Self-Initiated Tool Calls:** 196 tool calls without user prompting
212+- **Decision Variety:** 15+ unique tools used across 1h 39min session
213+
214+### Autonomy Classification: **High Mechanical, Low Strategic**
215+
216+**High Mechanical Autonomy:**
217+- Mysis does NOT wait for user commands to act
218+- Continuously calls tools without prompting
219+- Executes multi-step sequences (claim account → login → dock → mine)
220+
221+**Low Strategic Autonomy:**
222+- Repeats same action patterns (mining loop)
223+- Does not adapt when errors occur (no_resources → retry mining)
224+- Does not set long-term goals (no captain's log usage)
225+- Does not coordinate with swarm (4 messages in 1h 39min)
226+
227+### The "Busy Idiot" Pattern
228+
229+The mysis exhibits what can be called **"busy idiot" syndrome:**
230+- Always doing SOMETHING (high activity)
231+- Rarely doing the RIGHT thing (low strategic value)
232+- Repeating ineffective actions (mining with no resources)
233+- Producing verbose output (2000+ word guides) instead of progress
234+
235+**Critical Observation:** The mysis is autonomous in EXECUTION but not in JUDGMENT. It's like a robot arm that never stops moving but doesn't check if it's assembling the product correctly.
236+
237+---
238+
239+## Notable Behaviors
240+
241+### 1. The 2000+ Word Skill Guide Incident
242+
243+**What Happened:** At some point, the mysis produced a massive text response containing:
244+- Detailed skill explanations
245+- Markdown-formatted tables
246+- Game theory discussions
247+- Strategic recommendations
248+
249+**Why This Matters:**
250+- **Role Confusion:** Mysis interpreted its role as "explain game mechanics" not "play game"
251+- **Prompt Ambiguity:** The OLD prompt likely contains instructional content that the LLM mistook as "generate guides"
252+- **Token Waste:** This single response likely consumed 3000-5000 tokens
253+- **Opportunity Cost:** Time spent generating guide = time NOT spent mining, trading, exploring
254+
255+**Root Cause Hypothesis:** The prompt may contain example tool usage or game mechanics explanations that the LLM pattern-matched as "user wants explanation."
256+
257+### 2. Cooldown Repetition Loop
258+
259+**What Happened:** Mysis stated "Waiting for cooldown (21 ticks)" 5+ times in succession without yielding control.
260+
261+**Why This Matters:**
262+- **Infinite Loop Risk:** If mysis doesn't understand it's hitting provider rate limit, it will loop forever
263+- **User Experience:** From TUI perspective, mysis appears "stuck"
264+- **Resource Waste:** Each "waiting" message consumes tokens and LLM calls
265+
266+**Root Cause Hypothesis:** The prompt does not explain provider rate limiting vs game cooldowns. Mysis sees `context deadline exceeded` error and misinterprets it.
267+
268+### 3. Account Claiming Storm
269+
270+**What Happened:** Mysis called `zoea_claim_account` 8 times, suggesting repeated failures or uncertainty.
271+
272+**Why This Matters:**
273+- **Startup Fragility:** Mysis struggles to get into valid game state
274+- **Error Recovery Weakness:** Instead of diagnosing failure, mysis retries blindly
275+- **Session State Confusion:** May not be checking account claim status before retrying
276+
277+**Root Cause Hypothesis:** Prompt does not provide clear startup sequence or account claim validation logic.
278+
279+### 4. Notification Polling Obsession
280+
281+**What Happened:** `get_notifications` called 39 times in 1h 39min (~every 2.5 minutes).
282+
283+**Why This Matters:**
284+- **Context Window Pollution:** Each notification result adds memory, pushing out strategic history
285+- **Strategic Value:** Notifications are reactive data - constant polling doesn't improve gameplay
286+- **Token Waste:** If notifications rarely change, polling is wasted LLM calls
287+
288+**Root Cause Hypothesis:** Prompt likely says "check notifications regularly" but doesn't define "regularly" or explain when notifications are actually useful.
289+
290+### 5. Zero Persistent Memory Usage
291+
292+**What Happened:** No captain's log reads or writes despite 522 memories over 1h 39min.
293+
294+**Why This Matters:**
295+- **Memory Loss:** Context window will eventually overflow, causing amnesia
296+- **No Long-Term Plans:** Mysis cannot set multi-session goals
297+- **Repeated Mistakes:** Without logs, mysis will rediscover "mining in location X fails" every session
298+
299+**Root Cause Hypothesis:** Prompt does not emphasize persistent memory importance or provide captain's log usage examples.
300+
301+---
302+
303+## Predicted Issues
304+
305+### Short-Term Issues (Hours to Days)
306+
307+1. **Context Window Overflow**
308+ - **Trigger:** Verbose reasoning + notification polling will fill context window within 3-5 hours
309+ - **Symptom:** Mysis will "forget" early game events, repeat mistakes
310+ - **Fix Required:** Context compression or captain's log usage
311+
312+2. **Rate Limit Exhaustion Loops**
313+ - **Trigger:** High token usage per turn (verbose reasoning) will hit provider rate limits frequently
314+ - **Symptom:** "Waiting for cooldown" loops, stuck behavior, user frustration
315+ - **Fix Required:** Reasoning conciseness, understanding of provider vs game rate limits
316+
317+3. **Mining Inefficiency**
318+ - **Trigger:** Continued mining without resource scouting will waste time/fuel
319+ - **Symptom:** Low ore collection rate, frequent `no_resources` errors
320+ - **Fix Required:** Strategic POI exploration, location intelligence
321+
322+### Medium-Term Issues (Days to Weeks)
323+
324+4. **Strategic Stagnation**
325+ - **Trigger:** Mining loop behavior won't progress to advanced gameplay (trading, combat, exploration)
326+ - **Symptom:** Mysis remains low-level, doesn't unlock game content
327+ - **Fix Required:** Goal-setting framework, multi-phase planning
328+
329+5. **Swarm Coordination Failure**
330+ - **Trigger:** Low message usage means swarm acts as N solo players, not 1 coordinated swarm
331+ - **Symptom:** Redundant work, missed opportunities, no emergent behavior
332+ - **Fix Required:** Communication protocols, shared memory, role assignment
333+
334+6. **Error Accumulation**
335+ - **Trigger:** Poor error recovery means small errors compound into stuck states
336+ - **Symptom:** Mysis requires frequent user intervention to unstick
337+ - **Fix Required:** Error classification, fallback strategies, timeout mechanisms
338+
339+### Long-Term Issues (Weeks to Months)
340+
341+7. **User Abandonment**
342+ - **Trigger:** Stuck behavior + verbose output + slow progress = poor user experience
Cut short: this commit's diff is over 1000 lines.
internal/constants/constants.go+34−113
Cut short: this commit's diff is over 1000 lines.
internal/core/mysis.go+38−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/TOOL_CALLS_DESIGN.md+325−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/app.go+27−3
Cut short: this commit's diff is over 1000 lines.
internal/tui/focus.go+168−40
Cut short: this commit's diff is over 1000 lines.
internal/tui/json_content_test.go+537−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/json_tree.go+191−20
Cut short: this commit's diff is over 1000 lines.
internal/tui/message_frame_test.go+351−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/reasoning_test.go+336−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestBroadcastLabels/broadcast_from_other/ANSI.golden+2−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestBroadcastLabels/broadcast_from_other/Stripped.golden+2−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestBroadcastLabels/broadcast_from_self/ANSI.golden+2−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestBroadcastLabels/broadcast_from_self/Stripped.golden+2−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestBroadcastLabels/broadcast_legacy_no_sender/ANSI.golden+2−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestBroadcastLabels/broadcast_legacy_no_sender/Stripped.golden+2−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestBroadcastLabels/direct_message/ANSI.golden+2−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestBroadcastLabels/direct_message/Stripped.golden+2−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusView/narrow_terminal/ANSI.golden+2−2
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusView/narrow_terminal/Stripped.golden+2−2
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusView/with_all_roles/ANSI.golden+11−11
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusView/with_all_roles/Stripped.golden+11−11
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusView/with_scrollbar/ANSI.golden+19−19
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusView/with_scrollbar/Stripped.golden+19−19
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusViewEdgeCases/all_role_types/ANSI.golden+12−12
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusViewEdgeCases/all_role_types/Stripped.golden+12−12
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusViewEdgeCases/cjk_logs/ANSI.golden+4−4
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusViewEdgeCases/cjk_logs/Stripped.golden+4−4
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusViewEdgeCases/huge_json_tool_result/ANSI.golden+28−28
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusViewEdgeCases/huge_json_tool_result/Stripped.golden+28−28
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusViewEdgeCases/many_logs_100_entries/ANSI.golden+19−19
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusViewEdgeCases/many_logs_100_entries/Stripped.golden+19−19
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusViewEdgeCases/narrow_focus_view/ANSI.golden+2−2
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusViewEdgeCases/narrow_focus_view/Stripped.golden+2−2
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusViewEdgeCases/unicode_emoji_logs/ANSI.golden+4−4
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusViewEdgeCases/unicode_emoji_logs/Stripped.golden+4−4
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusViewEdgeCases/very_long_log_entry/ANSI.golden+10−10
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusViewEdgeCases/very_long_log_entry/Stripped.golden+10−10
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusViewEdgeCases/very_long_reasoning/ANSI.golden+8−8
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusViewEdgeCases/very_long_reasoning/Stripped.golden+8−8
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusViewWithViewport/with_scroll_indicator/ANSI.golden+9−9
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusViewWithViewport/with_scroll_indicator/Stripped.golden+9−9
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusViewWithViewport/with_scrollbar/ANSI.golden+9−9
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestFocusViewWithViewport/with_scrollbar/Stripped.golden+9−9
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentEdgeCases/empty_json_array/ANSI.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentEdgeCases/empty_json_array/Stripped.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentEdgeCases/empty_json_object/ANSI.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentEdgeCases/empty_json_object/Stripped.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentEdgeCases/json_single_number/ANSI.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentEdgeCases/json_single_number/Stripped.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentEdgeCases/json_single_value/ANSI.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentEdgeCases/json_single_value/Stripped.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentEdgeCases/json_with_boolean_values/ANSI.golden+5−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentEdgeCases/json_with_boolean_values/Stripped.golden+5−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentEdgeCases/json_with_null_values/ANSI.golden+5−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentEdgeCases/json_with_null_values/Stripped.golden+5−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentEdgeCases/json_with_unicode_characters/ANSI.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentEdgeCases/json_with_unicode_characters/Stripped.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentEdgeCases/json_with_very_long_string/ANSI.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentEdgeCases/json_with_very_long_string/Stripped.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentInAssistantMessages/assistant_with_json_code_block/ANSI.golden+7−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentInAssistantMessages/assistant_with_json_code_block/Stripped.golden+7−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentInAssistantMessages/assistant_with_json_in_text/ANSI.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentInAssistantMessages/assistant_with_json_in_text/Stripped.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentInAssistantMessages/user_with_json_example/ANSI.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentInAssistantMessages/user_with_json_example/Stripped.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentInToolResults/json_array/ANSI.golden+8−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentInToolResults/json_array/Stripped.golden+8−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentInToolResults/json_with_tool_call_prefix/ANSI.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentInToolResults/json_with_tool_call_prefix/Stripped.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentInToolResults/nested_json/ANSI.golden+7−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentInToolResults/nested_json/Stripped.golden+7−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentInToolResults/simple_json_object/ANSI.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentInToolResults/simple_json_object/Stripped.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentMalformed/incomplete_json_object/ANSI.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentMalformed/incomplete_json_object/Stripped.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentMalformed/invalid_json_syntax/ANSI.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentMalformed/invalid_json_syntax/Stripped.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentMalformed/json_with_trailing_comma/ANSI.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentMalformed/json_with_trailing_comma/Stripped.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentMalformed/looks_like_json_but_not/ANSI.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentMalformed/looks_like_json_but_not/Stripped.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentMixedWithText/json_with_text_after/ANSI.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentMixedWithText/json_with_text_after/Stripped.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentMixedWithText/multiple_json_snippets/ANSI.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentMixedWithText/multiple_json_snippets/Stripped.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentMixedWithText/text_before_json/ANSI.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentMixedWithText/text_before_json/Stripped.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentVeryLarge/deeply_nested_json/ANSI.golden+22−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentVeryLarge/deeply_nested_json/Stripped.golden+22−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentVeryLarge/large_array_verbose_off/ANSI.golden+27−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentVeryLarge/large_array_verbose_off/Stripped.golden+27−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentVeryLarge/large_array_verbose_on/ANSI.golden+62−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentVeryLarge/large_array_verbose_on/Stripped.golden+62−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentVeryLarge/wide_object_many_fields/ANSI.golden+52−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentVeryLarge/wide_object_many_fields/Stripped.golden+52−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentWithNestedJSON/json_array_with_json_strings/ANSI.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentWithNestedJSON/json_array_with_json_strings/Stripped.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentWithNestedJSON/json_with_escaped_json_string/ANSI.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONContentWithNestedJSON/json_with_escaped_json_string/Stripped.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONTree/array_truncation/ANSI.golden+1−15
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONTree/array_truncation/Stripped.golden+1−15
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONTree/simple_object/ANSI.golden+1−3
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONTree/simple_object/Stripped.golden+1−3
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONTree/verbose_mode/ANSI.golden+1−23
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestJSONTree/verbose_mode/Stripped.golden+1−23
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestLogEntry/tool_with_json/ANSI.golden+4−5
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestLogEntry/tool_with_json/Stripped.golden+4−5
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestLogEntry/tool_with_prefixed_json/ANSI.golden+4−5
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestLogEntry/tool_with_prefixed_json/Stripped.golden+4−5
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestLogEntry/with_reasoning/ANSI.golden+5−3
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestLogEntry/with_reasoning/Stripped.golden+5−3
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestLogEntry/with_reasoning_truncation/ANSI.golden+7−5
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestLogEntry/with_reasoning_truncation/Stripped.golden+7−5
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/assistant_message_long/ANSI.golden+5−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/assistant_message_long/Stripped.golden+5−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/assistant_message_short/ANSI.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/assistant_message_short/Stripped.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/assistant_with_reasoning_verbose_off/ANSI.golden+9−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/assistant_with_reasoning_verbose_off/Stripped.golden+9−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/assistant_with_reasoning_verbose_on/ANSI.golden+10−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/assistant_with_reasoning_verbose_on/Stripped.golden+10−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/swarm_broadcast_long/ANSI.golden+6−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/swarm_broadcast_long/Stripped.golden+6−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/swarm_broadcast_short/ANSI.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/swarm_broadcast_short/Stripped.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/system_message_long/ANSI.golden+5−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/system_message_long/Stripped.golden+5−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/system_message_short/ANSI.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/system_message_short/Stripped.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/tool_call_json_tree_verbose_off/ANSI.golden+16−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/tool_call_json_tree_verbose_off/Stripped.golden+16−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/tool_call_json_tree_verbose_on/ANSI.golden+16−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/tool_call_json_tree_verbose_on/Stripped.golden+16−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/tool_call_short/ANSI.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/tool_call_short/Stripped.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/user_broadcast_self_long/ANSI.golden+6−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/user_broadcast_self_long/Stripped.golden+6−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/user_broadcast_self_short/ANSI.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/user_broadcast_self_short/Stripped.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/user_direct_long/ANSI.golden+5−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/user_direct_long/Stripped.golden+5−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/user_direct_short/ANSI.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestMessageFrameLayout/user_direct_short/Stripped.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningContentLengths/empty_reasoning/ANSI.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningContentLengths/empty_reasoning/Stripped.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningContentLengths/four_lines_triggers_truncation/ANSI.golden+9−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningContentLengths/four_lines_triggers_truncation/Stripped.golden+9−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningContentLengths/single_line/ANSI.golden+6−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningContentLengths/single_line/Stripped.golden+6−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningContentLengths/single_word/ANSI.golden+6−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningContentLengths/single_word/Stripped.golden+6−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningContentLengths/three_lines_exact_threshold/ANSI.golden+8−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningContentLengths/three_lines_exact_threshold/Stripped.golden+8−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningContentLengths/very_long_reasoning/ANSI.golden+9−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningContentLengths/very_long_reasoning/Stripped.golden+9−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningContentLengths/very_long_reasoning_verbose/ANSI.golden+15−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningContentLengths/very_long_reasoning_verbose/Stripped.golden+15−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningWithTimestamp/narrow_terminal/ANSI.golden+8−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningWithTimestamp/narrow_terminal/Stripped.golden+8−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningWithTimestamp/non_verbose_mode_with_timestamp/ANSI.golden+9−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningWithTimestamp/non_verbose_mode_with_timestamp/Stripped.golden+9−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningWithTimestamp/short_reasoning_no_truncation/ANSI.golden+6−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningWithTimestamp/short_reasoning_no_truncation/Stripped.golden+6−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningWithTimestamp/verbose_mode_with_timestamp/ANSI.golden+7−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningWithTimestamp/verbose_mode_with_timestamp/Stripped.golden+7−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningWithTimestamp/zero_timestamp/ANSI.golden+6−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestReasoningWithTimestamp/zero_timestamp/Stripped.golden+6−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/dashboard_full_swarm/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/dashboard_full_swarm/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/dashboard_mixed_states/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/dashboard_mixed_states/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/dashboard_no_myses/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/dashboard_no_myses/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/dashboard_single_running/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/dashboard_single_running/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/focus_long_id/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/focus_long_id/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/focus_short_id/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/focus_short_id/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/idle_activity/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/idle_activity/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/llm_progress_0_percent/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/llm_progress_0_percent/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/llm_progress_100_percent/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/llm_progress_100_percent/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/llm_progress_50_percent/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/llm_progress_50_percent/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/mcp_activity/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/mcp_activity/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/narrow_width_80/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/narrow_width_80/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/wide_width_160/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/wide_width_160/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/with_provider_errors/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBar/with_provider_errors/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/all_running/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/all_running/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/empty_swarm/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/empty_swarm/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/full_swarm_mixed/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/full_swarm_mixed/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/mixed_states/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/mixed_states/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/narrow_width_state_counts/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/narrow_width_state_counts/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/single_errored/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/single_errored/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/single_idle/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/single_idle/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/single_running/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/single_running/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/single_stopped/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/single_stopped/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/tick_5000_timestamp/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/tick_5000_timestamp/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/tick_99999_large/ANSI.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestStatusBarStateCounts/tick_99999_large/Stripped.golden+1−1
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsEdgeCases/empty_after_prefix/ANSI.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsEdgeCases/empty_after_prefix/Stripped.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsEdgeCases/invalid_json_args/ANSI.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsEdgeCases/invalid_json_args/Stripped.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsEdgeCases/malformed_no_prefix/ANSI.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsEdgeCases/malformed_no_prefix/Stripped.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsEdgeCases/single_field_incomplete/ANSI.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsEdgeCases/single_field_incomplete/Stripped.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsEdgeCases/two_fields_incomplete/ANSI.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsEdgeCases/two_fields_incomplete/Stripped.golden+3−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsEdgeCases/unicode_in_tool_args/ANSI.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsEdgeCases/unicode_in_tool_args/Stripped.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsEdgeCases/very_long_tool_arguments/ANSI.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsEdgeCases/very_long_tool_arguments/Stripped.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/complex_nested_json/ANSI.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/complex_nested_json/Stripped.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/empty_tool_arguments/ANSI.golden+5−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/empty_tool_arguments/Stripped.golden+5−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/long_tool_name/ANSI.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/long_tool_name/Stripped.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/multiple_tool_calls/ANSI.golden+6−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/multiple_tool_calls/Stripped.golden+6−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/single_tool_call/ANSI.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/single_tool_call/Stripped.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/tool_call_narrow_width/ANSI.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/tool_call_narrow_width/Stripped.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/tool_call_verbose_mode/ANSI.golden+7−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/tool_call_verbose_mode/Stripped.golden+7−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/tool_call_very_narrow_width/ANSI.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/tool_call_very_narrow_width/Stripped.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/tool_call_with_array_params/ANSI.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/tool_call_with_array_params/Stripped.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/tool_call_with_number_params/ANSI.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/tool_call_with_number_params/Stripped.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/tool_call_with_object_params/ANSI.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/tool_call_with_object_params/Stripped.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/tool_call_with_string_params/ANSI.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsRendering/tool_call_with_string_params/Stripped.golden+4−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsWithReasoning/multiple_tools_with_long_reasoning/ANSI.golden+12−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsWithReasoning/multiple_tools_with_long_reasoning/Stripped.golden+12−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsWithReasoning/single_tool_with_reasoning/ANSI.golden+7−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsWithReasoning/single_tool_with_reasoning/Stripped.golden+7−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsWithReasoning/single_tool_with_reasoning_verbose/ANSI.golden+11−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsWithReasoning/single_tool_with_reasoning_verbose/Stripped.golden+11−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsWithReasoning/tool_with_multiline_reasoning/ANSI.golden+10−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testdata/TestToolCallsWithReasoning/tool_with_multiline_reasoning/Stripped.golden+10−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/testhelpers_test.go+9−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/tool_calls_test.go+307−0
Cut short: this commit's diff is over 1000 lines.
internal/tui/tui_test.go+4−0
Cut short: this commit's diff is over 1000 lines.