fix: make TUI subprocess calls async to resolve UI freezing (#215)

[dion-jy]

Summary

• Metadata polling (tmux capture-pane, git diff): moved from synchronous Update() to async tea.Cmd pattern — UI blocking drops from 100ms+ to µs per tick
• Preview capture (tmux capture-pane): same async pattern applied — no longer freezes UI while capturing pane content
• Trust screen detection: polling loop moved from blocking Start() to a background goroutine — session creation returns immediately

Fixes #215

Problem

The bubbletea Update() handler was calling subprocess commands synchronously. Every metadata tick blocked the entire UI for 100-500ms depending on disk speed. With multiple sessions, this scaled linearly (e.g., 8 sessions × 200ms = 1.6s of UI freeze per tick cycle). Even with a single session, keystrokes were noticeably delayed.

Approach

Converted blocking subprocess calls into the standard bubbletea async pattern:

1. Update() captures state and returns a tea.Cmd closure (returns in µs)
2. The closure runs subprocess calls in a bubbletea-managed goroutine
3. Results come back as a new message type, applied on the main event loop

Thread safety is maintained because:

• Goroutines only perform stateless subprocess calls (read-only)
• All mutable state writes happen exclusively on the main event loop thread
• Next tick is scheduled only after the result message is processed (no concurrent goroutine overlap)

Changed files

File	Change
app/app.go	Async metadata tick + async preview tick handlers
session/instance.go	Added SetDiffStats() for async result application
session/tmux/tmux.go	Trust screen polling moved to goroutine
ui/preview.go	Added SetPreviewContent() for async preview
ui/tabbed_window.go	Added SetPreviewContent() delegation

Benchmark results (before → after)

(you can check benchmark code here, https://github.com/CUN-bjy/claude-squad/tree/fix/tui-performance-215-with-tests)

Scenario	OLD (sync)	NEW (async)	Speedup
Metadata tick (1 session, typical)	107ms	4µs	26,000x
Preview tick (1 session, typical)	50ms	5µs	9,000x
Metadata tick (8 sessions, slow disk)	1.66s	4µs	414,000x
End-to-end keystroke responsiveness	323ms blocked	6µs blocked	53,000x

Note: Total work time is unchanged — subprocesses still run in the background. The improvement is in UI blocking time (how long keystrokes are delayed).

Test plan

• All existing tests pass (go test ./...)
• Race detector clean (go test -race ./...)
• Before/after benchmark comparison tests added
• Trust screen async goroutine verification tests added
• Manual testing: confirmed TUI is responsive with real sessions

If you find my work helpful, fuel the next commit with a coffee ☕

🤖 Generated with Claude Code

[github-actions]

All contributors have signed the CLA ✍️ ✅
_{Posted by the CLA Assistant Lite bot.}

[dion-jy]

I have read the CLA Document and I hereby sign the CLA

[miamachine]

Hey @dion-jy — great work on this, I have a similar PR open (#253) that tackles the same root issue. Wanted to flag it so the maintainers can see both and decide how to proceed, but I think they're different enough to land separately.

The main differences:

• Metadata parallelism: your PR moves the metadata loop into a single background goroutine, but instances still run sequentially inside it. fix: move expensive operations off UI event loop and fix stale preview pane #253 spawns one goroutine per instance with sync.WaitGroup, so all instances are checked in parallel — wall-clock time equals the slowest single instance regardless of how many are running.
• Session creation: fix: move expensive operations off UI event loop and fix stale preview pane #253 also moves instance.Start() to a background goroutine with a Loading status + spinner, which your PR doesn't cover.
• Preview + trust screen: your PR makes preview capture and trust-screen polling async, which fix: move expensive operations off UI event loop and fix stale preview pane #253 doesn't touch — those could be a nice follow-on after both of these land.

Not trying to compete, just wanted to make the overlap visible. Happy to coordinate if it helps.