Fix(abctl): keep the innermost exchange's corners in deeply-nested spans

A request/response pair nested three or more levels deep — e.g. a
tools/list pair inside an a2a message/stream span inside a long-lived
$transport/stream span — rendered "││" on both rows instead of "│┌" /
"│└", so the pair didn't read as connected. computeSpanGlyphs caps the
PHASE prefix at two levels and was picking the two WIDEST enclosing
spans, whose middle bars masked the row's own corner.

Pick the inner glyph from the row's NARROWEST containing span (its own
tightest exchange) instead of the second-widest, so an endpoint of a
deeply-nested pair always shows its ┌/└ corner. The outer glyph still
shows the broadest enclosing span for context. Adds a triple-nested
test case covering exactly this shape.

Assisted-By: Claude (Anthropic AI) <noreply@anthropic.com>
Signed-off-by: Hai Huang <huang195@gmail.com>

Author: huang195

authbridge/cmd/abctl/tui/events_pane.go

@@ -615,15 +615,24 @@ func computeSpanGlyphs(pairs map[int]int, n int) []spanLevels {
 		if len(participating) == 0 {
 			continue
 		}
-		// Sort by width descending — outer (widest) first, then inner. Stable
-		// so equal-width spans keep declaration order (deterministic tests).
+		// Sort by width descending — widest first, narrowest last. Stable so
+		// equal-width spans keep declaration order (deterministic tests).
 		sort.SliceStable(participating, func(p, q int) bool {
 			return (participating[p].b - participating[p].a) >
 				(participating[q].b - participating[q].a)
 		})
+		// outer = the widest containing span (the broadest context). inner =
+		// the NARROWEST containing span — the row's own tightest exchange —
+		// NOT the second-widest. A row that is an endpoint of a deeply-nested
+		// pair must still show its ┌/└ corner so its request and response
+		// connect visually; picking the second-widest would let an
+		// intermediate enclosing span's middle bar mask it. Example: a
+		// tools/list pair nested inside both an a2a message/stream span and a
+		// long-lived $transport/stream span would otherwise render "││" on
+		// both rows instead of "│┌" / "│└".
 		out[i].outer = glyphAt(participating[0], i)
 		if len(participating) > 1 {
-			out[i].inner = glyphAt(participating[1], i)
+			out[i].inner = glyphAt(participating[len(participating)-1], i)
 		}
 	}
 	return out

authbridge/cmd/abctl/tui/events_pane_test.go

@@ -685,6 +685,28 @@ func TestComputeSpanGlyphs(t *testing.T) {
 				outer(glyphEnd),
 			},
 		},
+		{
+			// The #52 case: a pair (2,3) nested THREE deep — inside a middle
+			// span (1,4) inside an outer span (0,5). The innermost pair's
+			// endpoints must still show their ┌/└ corners (so its req/resp
+			// connect) rather than the middle span's bar masking them. inner =
+			// the row's narrowest containing span, not the second-widest.
+			name: "triple-nested innermost pair keeps its corners",
+			pairs: map[int]int{
+				0: 5, 5: 0,
+				1: 4, 4: 1,
+				2: 3, 3: 2,
+			},
+			n: 6,
+			want: []spanLevels{
+				outer(glyphStart),             // 0: outer starts
+				both(glyphMiddle, glyphStart), // 1: outer mid, middle-span starts
+				both(glyphMiddle, glyphStart), // 2: outer mid, innermost STARTS (was masked to middle)
+				both(glyphMiddle, glyphEnd),   // 3: outer mid, innermost ENDS (was masked to middle)
+				both(glyphMiddle, glyphEnd),   // 4: outer mid, middle-span ends
+				outer(glyphEnd),               // 5: outer ends
+			},
+		},
 	}
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {