cli: a rule reads both sides of the cut, and a node is the boundary

Two defects in one predicate, both reported from the screen.

A TOOL'S BODY IS NOT A BLOCK OF ITS OWN. The junction asked whether the
hidden row beyond the rule drew the same gutter, so a tool scrolled until
only its output showed got a bare rule: the row above (its `✓ $ …`
header) carries no gutter, though it is the same block, and the line the
reader sees plainly runs under the chrome. "Cut" now asks about the
BLOCK: the hidden row draws the same gutter, OR belongs to the same
block. A tool that BEGINS under the rule still joins nothing.

AND THE OTHER SIDE WAS NEVER ASKED. Only the row below the rule could
cut it, so a quoted question, whose own gutter runs under the header,
could not. Each side is asked on its own now and all four glyphs happen:
┼ when one line passes straight through, ┴ when only the question above
is cut, ┬ when only the block below is, ─ when neither. Two lines cut at
different columns get a stroke each.

The floor calls the same function with an empty lower side: there is
nothing under it but the status bar.

Author: gluck

internal/cli/gutter_junction_test.go

@@ -144,30 +144,39 @@ func TestStickyRuleJoinsOnlyTheNextRowsGutter(t *testing.T) {
 }
 
 func TestJoinRule(t *testing.T) {
-	// far is the row on the other side of the rule: the one the chrome covers.
-	// A gutter on both sides is CUT by the rule and gets a junction; a gutter
-	// that begins or ends against it is a whole line and gets none.
+	// A stroke says the line GOES ON past the rule on that side. The row a
+	// reader sees carries the gutter; what the chrome hides beyond it says
+	// whether the line is cut there or simply begins (or ends) against it.
+	gutter := "  │ x"
 	for _, tc := range []struct {
-		name, near, far, want string
+		name         string
+		above, below gutterCut
+		want         string
 	}{
-		{"tool gutter", "  │ result", "  │ result", "──┬─────"},
-		{"left spine", "│ mantra", "│ mantra", "┬───────"},
-		{"styled gutter", "\x1b[2m  │\x1b[0m result", "  │ x", "──┬─────"},
-		{"split style", " \x1b[2m │\x1b[m", "  │", "──┬─────"},
-		{"prose", "  ordinary text", "  │ x", "────────"},
-		{"embedded vertical", "  text │ table", "  │ x", "────────"},
-		{"ascii pipe", "  | plain", "  │ x", "────────"},
-		{"corner", "  ╯", "  │ x", "────────"},
-		{"blank", "\x1b[2m   \x1b[m", "  │ x", "────────"},
-		{"past width", "        │", "        │", "────────"},
-		{"last column", "       │", "       │", "───────┬"},
-		{"block boundary", "  │ first row", "∨ The Boss", "────────"},
-		{"nothing beyond", "  │ last row", "", "────────"},
-		{"gutter moved", "  │ here", "    │ there", "────────"},
+		{"nothing at all", gutterCut{}, gutterCut{}, "────────"},
+		{"a block that ends against the rule", gutterCut{row: gutter}, gutterCut{}, "────────"},
+		{"a block that begins under it", gutterCut{}, gutterCut{row: gutter}, "────────"},
+		{"cut from above", gutterCut{row: gutter, hidden: gutter}, gutterCut{}, "──┴─────"},
+		{"cut from below", gutterCut{}, gutterCut{row: gutter, hidden: gutter}, "──┬─────"},
+		{"one line straight through", gutterCut{row: gutter, hidden: gutter},
+			gutterCut{row: gutter, hidden: gutter}, "──┼─────"},
+		{"two lines, two columns", gutterCut{row: gutter, hidden: gutter},
+			gutterCut{row: "   │ x", hidden: "   │ y"}, "──┴┬────"},
+		// A tool's header carries no gutter and its body is the same block, so
+		// a rule between them cuts ONE line.
+		{"a tool cut under its header", gutterCut{},
+			gutterCut{row: gutter, hidden: "✓ $ ls", sameBlock: true}, "──┬─────"},
+		{"left spine", gutterCut{}, gutterCut{row: "│ mantra", hidden: "│ mode"}, "┬───────"},
+		{"styled gutter", gutterCut{}, gutterCut{row: "\x1b[2m  │\x1b[0m x", hidden: gutter}, "──┬─────"},
+		{"embedded vertical", gutterCut{}, gutterCut{row: "  text │ table", hidden: gutter}, "────────"},
+		{"ascii pipe", gutterCut{}, gutterCut{row: "  | plain", hidden: gutter}, "────────"},
+		{"past the rule's width", gutterCut{}, gutterCut{row: "        │", hidden: "        │"}, "────────"},
+		{"last column", gutterCut{}, gutterCut{row: "       │", hidden: "       │"}, "───────┬"},
+		{"columns disagree", gutterCut{}, gutterCut{row: "  │ here", hidden: "    │ there"}, "────────"},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			rule := "\x1b[2m────────\x1b[m"
-			got := joinRule(rule, tc.near, tc.far, "┬")
+			got := joinRule(rule, tc.above, tc.below)
 			if want := "\x1b[2m" + tc.want + "\x1b[m"; got != want {
 				t.Fatalf("got %q, want %q", got, want)
 			}
@@ -252,3 +261,76 @@ func TestFooterRuleJoinsOnlyAGutterItCuts(t *testing.T) {
 		t.Fatalf("the last row of a block joins nothing, got %q", rule)
 	}
 }
+
+// quotedPager is a turn whose question is a QUOTE (a markdown blockquote, as
+// the quoting gesture writes one), so the question itself has a gutter that
+// can meet the header's rule from above. n says how many lines of it.
+func quotedPager(t testing.TB, lines int) *transcript {
+	t.Helper()
+	quote := "> quoting aria bd0cf2bd · turn 3 · lt 63.1 · chars 3033-3067 (34 chars)"
+	for range lines - 1 {
+		quote += "\n> and another line of the passage, long enough to stand on its own row"
+	}
+	client := aria.NewClient()
+	client.Apply(aria.Page{Parts: []aria.TurnPart{{Turn: aria.Turn{
+		ID: 1, Sealed: true, Inquiry: quote,
+		InquirySegments: []aria.InquirySegment{{Sender: "Gluck", Text: quote}},
+		Nodes: []livedoc.Node{
+			{Type: livedoc.NodeTool, Name: "bash", Status: livedoc.StatusOK,
+				Args:   map[string]any{"command": "grep -rn federate ."},
+				Output: "(no output)\nsecond line\nthird line\nfourth line"},
+			{Type: livedoc.NodeThinking, Markdown: "Thinking about the loop."},
+		},
+	}}}}, aria.Notify)
+	view := &ariaView{settings: &renderSettings{sticky: true}}
+	tr := newTranscript(ldrender.NewFakeTerminal(120, 12), 120, 12, view, client, "quoted01", time.Time{})
+	tr.enter()
+	tr.follow = false
+	tr.buildIndex()
+	return tr
+}
+
+// stickyRuleOver scrolls until the row under the header's rule holds want, and
+// answers the rule as painted.
+func stickyRuleOver(t *testing.T, tr *transcript, want string) string {
+	t.Helper()
+	_, maxOff := tr.layoutNow()
+	for off := 1; off <= maxOff; off++ {
+		tr.offset = off
+		lines := tr.stickyLines("", selectionSpan{})
+		if len(lines) == 0 {
+			continue
+		}
+		below := stripANSI(tr.lineAt(tr.offset + len(lines)))
+		if strings.Contains(below, want) {
+			return stripANSI(lines[len(lines)-1])
+		}
+	}
+	t.Fatalf("no offset puts %q under the header's rule", want)
+	return ""
+}
+
+// A NODE IS THE BOUNDARY, NOT ITS GUTTER. A tool's body carries the gutter and
+// its header row does not, so a rule between the two cuts ONE block and says
+// so, where a rule above a block that starts there says nothing.
+func TestStickyRuleReadsBothSidesOfTheCut(t *testing.T) {
+	// One line of question: nothing of it is left under the rule, so the only
+	// stroke is the tool's body, cut from its header above.
+	one := quotedPager(t, 1)
+	if rule := stickyRuleOver(t, one, "(no output)"); !strings.HasPrefix(rule, "──┬─") {
+		t.Errorf("a tool cut under its own header: %q", rule)
+	}
+	if rule := stickyRuleOver(t, one, "$ grep"); strings.ContainsAny(rule, "┬┴┼") {
+		t.Errorf("a tool that begins under the rule joins nothing: %q", rule)
+	}
+
+	// Several lines of question: its own gutter runs under the header too, so
+	// the rule carries the stroke for it as well.
+	many := quotedPager(t, 3)
+	if rule := stickyRuleOver(t, many, "(no output)"); !strings.HasPrefix(rule, "──┼─") {
+		t.Errorf("two cut lines make a crossing: %q", rule)
+	}
+	if rule := stickyRuleOver(t, many, "$ grep"); !strings.HasPrefix(rule, "──┴─") {
+		t.Errorf("the question alone is cut: %q", rule)
+	}
+}

internal/cli/transcript.go

@@ -1465,11 +1465,12 @@ func (t *transcript) renderFrame() {
 	// THE RULE THAT CLOSES THE CONVERSATION CARRIES THE JUNCTION, as the
 	// sticky header's does and for the same reason (see joinRule). Which rule
 	// that is depends on what is open: the pit's own when a panel is up, the
-	// footer's otherwise. A clipped stanza has lost its rule along with its
-	// head, and a fullscreen pit has no conversation under it to join.
-	floor := t.lineAt(t.offset + body)
+	// footer's otherwise. Nothing is below it but the status bar, so the floor
+	// only ever wears the up stroke. A clipped stanza has lost its rule along
+	// with its head, and a fullscreen pit has no conversation under it.
+	floor := t.lineCut(t.offset+body-1, t.offset+body)
 	if len(foot) > 0 && !clipped && !t.fullPit() && start > 0 {
-		foot[0] = joinRule(foot[0], screen[start-1], floor, "┴")
+		foot[0] = joinRule(foot[0], floor, gutterCut{})
 	}
 	for k, l := range foot {
 		if r := start + k; r >= 0 && r < t.h-len(bar) {
@@ -1490,7 +1491,7 @@ func (t *transcript) renderFrame() {
 	// however many rows that is.
 	if top := t.h - 1 - len(bar); top >= 0 {
 		if rule != "" && len(foot) == 0 && top > 0 {
-			rule = joinRule(rule, screen[top-1], floor, "┴")
+			rule = joinRule(rule, floor, gutterCut{})
 		}
 		screen[top] = rule
 		for i, row := range bar {

internal/cli/transcript_sticky.go

@@ -174,33 +174,98 @@ func (t *transcript) stickyLines(hl string, sel selectionSpan) []string {
 	out[0] = ldrender.OverlayRight(out[0], term.Dim(coordLabel(turn, inquiryNode, 0, t.coordFormat())+" "), t.w-ldrender.GutterCols)
 	out[0] = ldrender.OverlayGutter(out[0], q.gutter, t.w)
 	if above >= len(q.rows) {
-		// The header covers rows rather than pushing them down. Join only
-		// to the first row still visible below its rule, never a covered row.
-		// The covered row directly above it says whether the gutter is CUT by
-		// the rule or merely begins under it: see joinRule.
-		rule := t.transRule()
-		below := t.lineAt(t.offset + len(out) + 1)
-		hidden := t.lineAt(t.offset + len(out))
-		out = append(out, joinRule(rule, below, hidden, "┬"))
+		// The header COVERS rows rather than pushing them down, so a gutter
+		// may run under it on either side. The rule says which: see joinRule.
+		seen := len(out)
+		out = append(out, joinRule(t.transRule(),
+			t.stickyCut(q, rows, seen),
+			t.lineCut(t.offset+seen+1, t.offset+seen)))
 	}
 	return out
 }
 
-// joinRule ties a horizontal rule to the vertical gutter that crosses it.
-// A JUNCTION MEANS THE LINE GOES ON PAST THE RULE, and nothing else, so it is
-// drawn only where the gutter stands on BOTH sides: near, the row the reader
-// can see, and far, the row the chrome covers. A gutter that begins or ends
-// against the rule is a whole line already, and a junction there branches to
-// a block that is not there.
-func joinRule(rule, near, far, glyph string) string {
-	col, ok := gutterColumn(near)
-	if !ok || col >= displayWidth(rule) {
-		return rule
-	}
-	if other, ok := gutterColumn(far); !ok || other != col {
-		return rule
-	}
-	return ldrender.OverlayColumn(rule, col, glyph)
+// stickyCut is the gutter meeting the header's rule FROM ABOVE: the last
+// pinned row carries one, and the question goes on under the rule.
+func (t *transcript) stickyCut(q stickyQuestion, rows []transcriptRow, seen int) gutterCut {
+	cut := gutterCut{row: t.rowLine(rows[len(rows)-1], "", selectionSpan{})}
+	if seen < len(q.rows) {
+		cut.hidden = q.rows[seen].text
+		cut.sameBlock = q.rows[seen].ref == rows[len(rows)-1].ref
+	}
+	return cut
+}
+
+// lineCut is the gutter meeting a rule from the side the reader can see, where
+// `seen` is that row's absolute line and `hidden` the line the chrome covers
+// on the far side of the rule.
+func (t *transcript) lineCut(seen, hidden int) gutterCut {
+	ref := t.refAtLine(seen)
+	return gutterCut{
+		row:       t.lineAt(seen),
+		hidden:    t.lineAt(hidden),
+		sameBlock: ref.valid() && ref == t.refAtLine(hidden),
+	}
+}
+
+// refAtLine is the block an absolute line belongs to, or the zero ref for
+// chrome, a separator or a gap.
+func (t *transcript) refAtLine(i int) nodeRef {
+	k := t.index.entryAt(i)
+	if k < 0 {
+		return nodeRef{}
+	}
+	e := &t.index.entries[k]
+	return e.refAt(i - e.start)
+}
+
+// gutterCut is one side of a rule: the row the reader SEES there, plus what
+// the chrome hides immediately beyond it.
+type gutterCut struct {
+	row       string
+	hidden    string
+	sameBlock bool
+}
+
+// column answers where this side's gutter meets the rule, and whether the line
+// GOES ON past it: the hidden row draws the same gutter, or belongs to the
+// same block. The second half is what a tool block needs -- its header row
+// carries no gutter, but the body under it is the same block, so a rule
+// between them cuts one line, not two.
+func (c gutterCut) column() (int, bool) {
+	col, ok := gutterColumn(c.row)
+	if !ok {
+		return 0, false
+	}
+	if c.sameBlock {
+		return col, true
+	}
+	other, ok := gutterColumn(c.hidden)
+	return col, ok && other == col
+}
+
+// joinRule marks a rule where a block's vertical gutter is CUT by it. A stroke
+// says the line goes on past the rule on that side and nothing else: up when
+// the gutter above continues under it, down when the gutter below comes from
+// above it, ┼ where one line does both. A gutter that merely begins or ends
+// against the rule is a whole line already, and a junction there would branch
+// to a block that is not there.
+func joinRule(rule string, above, below gutterCut) string {
+	up, upOK := above.column()
+	down, downOK := below.column()
+	w := displayWidth(rule)
+	upOK = upOK && up < w
+	downOK = downOK && down < w
+	switch {
+	case upOK && downOK && up == down:
+		return ldrender.OverlayColumn(rule, up, "┼")
+	case upOK && downOK:
+		return ldrender.OverlayColumn(ldrender.OverlayColumn(rule, up, "┴"), down, "┬")
+	case upOK:
+		return ldrender.OverlayColumn(rule, up, "┴")
+	case downOK:
+		return ldrender.OverlayColumn(rule, down, "┬")
+	}
+	return rule
 }
 
 // gutterColumn is the column of a row's leading vertical rule, if it has one.

skills/figaro/reference/ui-stream.md

@@ -624,16 +624,28 @@ conversation with a rule at the bottom. Both rules are crossed by the gutters
 that run down the left of thinking, steering and tool blocks, and a **junction**
 (`┬` above, `┴` below) is drawn where one is.
 
-A junction says ONE thing: *this line goes on past the rule*. So it is drawn
-only when the gutter is on both sides of it: the row the reader can see, and
-the row the chrome covers. The first row of a block sitting under the sticky
-header joins nothing (the line begins there); the last row of a block sitting
-against the floor joins nothing either (the line ends there); scroll one row
-and the same rule grows its junction, because now the block really is cut.
+A stroke says ONE thing: *this line goes on past the rule*. Each side is asked
+separately, so all four glyphs happen:
+
+| | the gutter above is cut | it is not |
+|---|---|---|
+| **the gutter below is cut** | `┼` | `┬` |
+| **it is not** | `┴` | `─` |
+
+"Cut" is a question about the BLOCK, not about the glyph on the next row: the
+row the reader sees carries a gutter, and the row the chrome hides just beyond
+it either draws the same gutter or belongs to the same block. That second half
+is what a tool needs. Its header row (`✓ $ grep …`) carries no gutter while its
+body does, so a rule between them cuts one line and wears `┬`; a rule above a
+tool that BEGINS under it wears nothing. A quoted question works the same way
+from the other side: one line of it ends against the rule and draws nothing,
+several lines run under the header and draw `┴`, and if the row below is cut
+too the two strokes meet as `┼`.
 
 `joinRule` in `transcript_sticky.go` is the whole of it, and both the header
 and the floor call it, which is why they cannot disagree again: the floor used
-to draw no junctions at all while the header drew one unconditionally.
+to draw no junctions at all while the header drew one unconditionally. The
+floor never wears a down stroke; there is nothing under it but the status bar.
 
 ## Steering: messages mid-turn