Port PR #2 from Rust: text toggle, solo mode, dedup fix, tool names on output

- Fix show_text default (false → true) — text output was hidden with no toggle
- Add Text toggle (x key) in header
- Add solo mode (s key) — isolate a session/agent in tree view
- Remove destructive x/d delete — space toggle + solo covers filtering
- Show tool name on output headers (e.g., "Bash result (1.2s)")
- Fix dedup to key on (ToolID, Type) — input+output with same ID both kept
- Rename "Auto" to "Scroll" in header
- Update README keybindings

Based on phiat/claude-esp-rs#2 by @rdmontgomery

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: phiat

README.md

@@ -105,14 +105,15 @@ claude-esp -l
 | `t`       | Toggle thinking visibility                |
 | `i`       | Toggle tool input visibility              |
 | `o`       | Toggle tool output visibility             |
+| `x`       | Toggle text/response visibility           |
 | `a`       | Toggle auto-scroll                        |
 | `h`       | Hide/show tree pane                       |
 | `A`       | Toggle auto-discovery of new sessions     |
 | `tab`     | Switch focus between tree and stream      |
 | `j/k/↑/↓` | Navigate tree or scroll stream            |
 | `space`   | Toggle selected item in tree              |
+| `s`       | Solo selected session/agent (toggle)      |
 | `enter`   | Load background task output (when selected)|
-| `x/d`     | Remove selected session from tree         |
 | `g/G`     | Go to top/bottom of stream                |
 | `q`       | Quit                                      |
 

internal/tui/model.go

@@ -253,15 +253,13 @@ func (m *Model) handleKey(msg tea.KeyMsg) tea.Cmd {
 			m.stream.ToggleAutoScroll()
 		}
 
-	case "x", "d":
-		// Remove selected session (only when tree is focused)
-		if m.focus == FocusTree && m.watcher != nil {
-			sessionID := m.tree.GetSelectedSession()
-			if sessionID != "" {
-				m.watcher.RemoveSession(sessionID)
-				m.tree.RemoveSession(sessionID)
-				m.stream.SetEnabledFilters(m.tree.GetEnabledFilters())
-			}
+	case "x":
+		m.stream.ToggleText()
+
+	case "s":
+		if m.focus == FocusTree {
+			m.tree.Solo()
+			m.stream.SetEnabledFilters(m.tree.GetEnabledFilters())
 		}
 
 	case "A":
@@ -377,11 +375,12 @@ func (m *Model) renderHeader() string {
 	thinking := m.renderToggle("Thinking", m.stream.IsThinkingEnabled(), "t")
 	toolInput := m.renderToggle("Tools", m.stream.IsToolInputEnabled(), "i")
 	toolOutput := m.renderToggle("Output", m.stream.IsToolOutputEnabled(), "o")
-	autoScroll := m.renderToggle("Auto", m.stream.IsAutoScrollEnabled(), "a")
+	textToggle := m.renderToggle("Text", m.stream.IsTextEnabled(), "x")
+	autoScroll := m.renderToggle("Scroll", m.stream.IsAutoScrollEnabled(), "a")
 	treeToggle := m.renderToggle("Tree", m.showTree, "h")
 
-	toggles := fmt.Sprintf("%s  %s  %s  %s  %s",
-		thinking, toolInput, toolOutput, autoScroll, treeToggle)
+	toggles := fmt.Sprintf("%s  %s  %s  %s  %s  %s",
+		thinking, toolInput, toolOutput, textToggle, autoScroll, treeToggle)
 
 	// Session count and auto-discovery status
 	sessionInfo := ""
@@ -475,7 +474,7 @@ func (m *Model) renderStreamOnly() string {
 func (m *Model) renderHelp() string {
 	var help string
 	if m.focus == FocusTree {
-		help = "j/k: navigate │ space: toggle │ x: remove │ A: auto-discover │ q: quit"
+		help = "j/k: navigate │ space: toggle │ s: solo │ A: auto-discover │ q: quit"
 	} else {
 		help = "j/k: scroll │ g/G: top/bottom │ A: auto-discover │ tab: tree │ q: quit"
 	}

internal/tui/stream.go

@@ -47,7 +47,7 @@ func NewStreamView() *StreamView {
 		showThinking:   true,
 		showToolInput:  true,
 		showToolOutput: true,
-		showText:       false, // hide main text by default
+		showText:       true,
 		enabledFilters: []EnabledFilter{},
 	}
 }
@@ -63,12 +63,14 @@ func (s *StreamView) SetSize(width, height int) {
 
 // AddItem adds a new item to the stream
 func (s *StreamView) AddItem(item parser.StreamItem) {
-	// Deduplicate tool input/output by ToolID
+	// Deduplicate by (ToolID, Type) so tool input and output
+	// with the same tool_id are both kept
 	if item.ToolID != "" {
-		if s.seenToolIDs[item.ToolID] {
+		dedupKey := fmt.Sprintf("%s:%s", item.ToolID, item.Type)
+		if s.seenToolIDs[dedupKey] {
 			return // Skip duplicate
 		}
-		s.seenToolIDs[item.ToolID] = true
+		s.seenToolIDs[dedupKey] = true
 	}
 
 	s.items = append(s.items, item)
@@ -103,6 +105,12 @@ func (s *StreamView) ToggleToolOutput() {
 	s.updateContent()
 }
 
+// ToggleText toggles text visibility
+func (s *StreamView) ToggleText() {
+	s.showText = !s.showText
+	s.updateContent()
+}
+
 // ToggleAutoScroll toggles auto-scroll
 func (s *StreamView) ToggleAutoScroll() {
 	s.autoScroll = !s.autoScroll
@@ -134,6 +142,11 @@ func (s *StreamView) IsToolOutputEnabled() bool {
 	return s.showToolOutput
 }
 
+// IsTextEnabled returns text filter state
+func (s *StreamView) IsTextEnabled() bool {
+	return s.showText
+}
+
 // IsAutoScrollEnabled returns auto-scroll state
 func (s *StreamView) IsAutoScrollEnabled() bool {
 	return s.autoScroll
@@ -215,7 +228,22 @@ func (s *StreamView) renderItem(item parser.StreamItem, width int) string {
 		b.WriteString(toolInputContentStyle.Render(content))
 
 	case parser.TypeToolOutput:
-		outputLabel := toolOutputIcon + " Output"
+		// Look up tool name from matching ToolInput
+		toolName := ""
+		if item.ToolID != "" {
+			for _, other := range s.items {
+				if other.Type == parser.TypeToolInput && other.ToolID == item.ToolID {
+					toolName = other.ToolName
+					break
+				}
+			}
+		}
+		var outputLabel string
+		if toolName != "" {
+			outputLabel = toolOutputIcon + " " + toolName + " result"
+		} else {
+			outputLabel = toolOutputIcon + " Output"
+		}
 		if item.DurationMs > 0 {
 			outputLabel += " " + formatDuration(item.DurationMs)
 		}

internal/tui/stream_test.go

@@ -41,6 +41,7 @@ func TestStreamView_Deduplication(t *testing.T) {
 	s := NewStreamView()
 	s.SetSize(80, 24)
 
+	// Input and output with same ToolID should both be kept (different types)
 	item1 := parser.StreamItem{
 		Type:      parser.TypeToolInput,
 		SessionID: "sess1",
@@ -57,10 +58,16 @@ func TestStreamView_Deduplication(t *testing.T) {
 	}
 
 	s.AddItem(item1)
-	s.AddItem(item2) // same ToolID, should be skipped
+	s.AddItem(item2)
 
-	if len(s.items) != 1 {
-		t.Errorf("expected 1 item (duplicate skipped), got %d", len(s.items))
+	if len(s.items) != 2 {
+		t.Errorf("expected 2 items (input + output kept), got %d", len(s.items))
+	}
+
+	// Duplicate of same type + same ToolID should be skipped
+	s.AddItem(item1)
+	if len(s.items) != 2 {
+		t.Errorf("expected 2 items (true duplicate skipped), got %d", len(s.items))
 	}
 }
 

internal/tui/tree.go

@@ -288,6 +288,67 @@ func (t *TreeView) Toggle() {
 	}
 }
 
+// Solo isolates the selected node: disables all others, enables only this one.
+// If already soloed, re-enables all.
+func (t *TreeView) Solo() {
+	if t.cursor < 0 || t.cursor >= len(t.nodes) {
+		return
+	}
+	selected := t.nodes[t.cursor]
+
+	if t.isSoloed(selected) {
+		// Un-solo: re-enable everything
+		setAllEnabled(t.Root, true)
+	} else {
+		// Disable all sessions and their children
+		for _, session := range t.Root.Children {
+			setAllEnabled(session, false)
+		}
+
+		// Enable the selected node and the path to it
+		switch selected.Type {
+		case NodeTypeSession:
+			setAllEnabled(selected, true)
+		case NodeTypeMain, NodeTypeAgent:
+			if selected.Parent != nil {
+				selected.Parent.Enabled = true
+			}
+			selected.Enabled = true
+		}
+	}
+}
+
+func (t *TreeView) isSoloed(selected *TreeNode) bool {
+	if !selected.Enabled {
+		return false
+	}
+
+	for _, session := range t.Root.Children {
+		if selected.Type == NodeTypeSession {
+			if session != selected && session.Enabled {
+				return false
+			}
+		} else {
+			for _, child := range session.Children {
+				if child.Type == NodeTypeBackgroundTask {
+					continue
+				}
+				if child != selected && child.Enabled {
+					return false
+				}
+			}
+		}
+	}
+	return true
+}
+
+func setAllEnabled(node *TreeNode, enabled bool) {
+	node.Enabled = enabled
+	for _, child := range node.Children {
+		setAllEnabled(child, enabled)
+	}
+}
+
 // GetSelectedSession returns the session ID of the currently selected node (or its parent session)
 func (t *TreeView) GetSelectedSession() string {
 	if t.cursor < 0 || t.cursor >= len(t.nodes) {