cf5ca03 Merge pull request #1 from bnema/refactor/scrollback-visual-mode · vev

M README.md +6 -6


@@ -49,26 +49,26 @@ All bindings use the Alt modifier directly, no prefix key.
49	49		\| Alt+d \| detach \|
50	50		\| Alt+r \| promote the current ephemeral session to named \|
51	51		\| Alt+t \| open session/tab picker \|
52		-	\| Alt+u \| enter copy mode \|
	52	+	\| Alt+u \| enter scrollback mode \|
53	53
54		-	## Copy mode
	54	+	## Scrollback and visual copy
55	55
56		-	Copy mode freezes a view over the scrollback while the program keeps running underneath. The status bar shows `[COPY]` and the cursor position.
	56	+	Scrollback mode freezes a view over history while the program keeps running underneath. Mouse wheel up enters scrollback mode and shows `[SCROLL]`; scrolling back down to the live bottom exits. When a line selection is active, the selected rows are highlighted and the status bar shows `[VISUAL]`.
57	57
58	58		\| Key \| Action \|
59	59		\|---\|---\|
60	60		\| j / k, Up / Down \| move one line \|
61	61		\| PgUp / PgDn \| move one page \|
62	62		\| g / G \| jump to top / bottom \|
63		-	\| Space \| toggle line selection \|
	63	+	\| Space \| toggle visual line selection \|
64	64		\| y or Enter \| copy selection and exit \|
65	65		\| q, Esc, Ctrl-C \| exit without copying \|
66	66
67		-	Copying uses OSC 52, so the selection lands in your terminal's clipboard even across SSH.
	67	+	Copying uses OSC 52, so the selection lands in your terminal's clipboard even across SSH. After a successful copy, the right side of the status bar reports `copied N chars to clipboard` until the next screen update. If the selection exceeds the OSC 52 copy limit, the status bar reports `selection too large to copy` instead.
68	68
69	69		## Mouse
70	70
71		-	vev enables terminal mouse reporting while attached. Mouse input on the status row is reserved for vev and is not sent to the child. In copy mode, the wheel scrolls the copy-mode view. When the child enables mouse reporting, SGR mouse events are forwarded to it. Otherwise, wheel events in the alternate screen are translated to Up/Down arrow keys (`ESC[A` / `ESC[B`). This translation intentionally does not honor DECCKM application-cursor mode (`ESC OA` / `ESC OB`). An extremely rare input read split exactly between `ESC[` and `<` in an SGR mouse sequence may leak the partial `ESC[` to the child.
	71	+	vev enables terminal mouse reporting while attached. Mouse input on the status row is reserved for vev and is not sent to the child. In scrollback mode, the wheel scrolls the scrollback view. When the child enables mouse reporting, SGR mouse events are forwarded to it. Otherwise, wheel events in the alternate screen are translated to Up/Down arrow keys (`ESC[A` / `ESC[B`). This translation intentionally does not honor DECCKM application-cursor mode (`ESC OA` / `ESC OB`). An extremely rare input read split exactly between `ESC[` and `<` in an SGR mouse sequence may leak the partial `ESC[` to the child.
72	72
73	73		vev follows the child application's cursor visibility and style requests and appends a hardware cursor update after each paint. Visible cursors blink as requested by the terminal/application state.
74	74


@@ -49,26 +49,26 @@ All bindings use the Alt modifier directly, no prefix key.
49		\| Alt+d \| detach \|	49		\| Alt+d \| detach \|
50		\| Alt+r \| promote the current ephemeral session to named \|	50		\| Alt+r \| promote the current ephemeral session to named \|
51		\| Alt+t \| open session/tab picker \|	51		\| Alt+t \| open session/tab picker \|
52	-	\| Alt+u \| enter copy mode \|	52	+	\| Alt+u \| enter scrollback mode \|
53			53
54	-	## Copy mode	54	+	## Scrollback and visual copy
55			55
56	-	Copy mode freezes a view over the scrollback while the program keeps running underneath. The status bar shows `[COPY]` and the cursor position.	56	+	Scrollback mode freezes a view over history while the program keeps running underneath. Mouse wheel up enters scrollback mode and shows `[SCROLL]`; scrolling back down to the live bottom exits. When a line selection is active, the selected rows are highlighted and the status bar shows `[VISUAL]`.
57			57
58		\| Key \| Action \|	58		\| Key \| Action \|
59		\|---\|---\|	59		\|---\|---\|
60		\| j / k, Up / Down \| move one line \|	60		\| j / k, Up / Down \| move one line \|
61		\| PgUp / PgDn \| move one page \|	61		\| PgUp / PgDn \| move one page \|
62		\| g / G \| jump to top / bottom \|	62		\| g / G \| jump to top / bottom \|
63	-	\| Space \| toggle line selection \|	63	+	\| Space \| toggle visual line selection \|
64		\| y or Enter \| copy selection and exit \|	64		\| y or Enter \| copy selection and exit \|
65		\| q, Esc, Ctrl-C \| exit without copying \|	65		\| q, Esc, Ctrl-C \| exit without copying \|
66			66
67	-	Copying uses OSC 52, so the selection lands in your terminal's clipboard even across SSH.	67	+	Copying uses OSC 52, so the selection lands in your terminal's clipboard even across SSH. After a successful copy, the right side of the status bar reports `copied N chars to clipboard` until the next screen update. If the selection exceeds the OSC 52 copy limit, the status bar reports `selection too large to copy` instead.
68			68
69		## Mouse	69		## Mouse
70			70
71	-	vev enables terminal mouse reporting while attached. Mouse input on the status row is reserved for vev and is not sent to the child. In copy mode, the wheel scrolls the copy-mode view. When the child enables mouse reporting, SGR mouse events are forwarded to it. Otherwise, wheel events in the alternate screen are translated to Up/Down arrow keys (`ESC[A` / `ESC[B`). This translation intentionally does not honor DECCKM application-cursor mode (`ESC OA` / `ESC OB`). An extremely rare input read split exactly between `ESC[` and `<` in an SGR mouse sequence may leak the partial `ESC[` to the child.	71	+	vev enables terminal mouse reporting while attached. Mouse input on the status row is reserved for vev and is not sent to the child. In scrollback mode, the wheel scrolls the scrollback view. When the child enables mouse reporting, SGR mouse events are forwarded to it. Otherwise, wheel events in the alternate screen are translated to Up/Down arrow keys (`ESC[A` / `ESC[B`). This translation intentionally does not honor DECCKM application-cursor mode (`ESC OA` / `ESC OB`). An extremely rare input read split exactly between `ESC[` and `<` in an SGR mouse sequence may leak the partial `ESC[` to the child.
72			72
73		vev follows the child application's cursor visibility and style requests and appends a hardware cursor update after each paint. Visible cursors blink as requested by the terminal/application state.	73		vev follows the child application's cursor visibility and style requests and appends a hardware cursor update after each paint. Visible cursors blink as requested by the terminal/application state.
74			74

M internal/usecase/copy/mode.go +6 -3


@@ -14,7 +14,7 @@ import (
14	14		// specific continuation protocol is supported.
15	15		const OSC52MaxPayloadBytes = 75_000
16	16
17		-	// Snapshot is the copy-mode document: scrollback followed by the live screen.
	17	+	// Snapshot is the scrollback-mode document: scrollback followed by the live screen.
18	18		type Snapshot struct {
19	19		Rows [][]renderer.Cell
20	20		Width int

@@ -39,7 +39,7 @@ func NewSnapshot(sb *Scrollback, screen renderer.Frame) Snapshot {
39	39		return Snapshot{Rows: rows, Width: screen.Width, Height: screen.Height}
40	40		}
41	41
42		-	// Mode stores per-client copy-mode viewport and line-selection state.
	42	+	// Mode stores per-client scrollback viewport and line-selection state.
43	43		type Mode struct {
44	44		ViewportTop int
45	45		Cursor int

@@ -166,7 +166,10 @@ func drawCopyStatus(row []renderer.Cell, m *Mode, total int) {
166	166		for i := range row {
167	167		row[i] = renderer.BlankCell()
168	168		}
169		-	text := " [COPY] "
	169	+	text := " [SCROLL] "
	170	+	if m.Selecting {
	171	+	text = " [VISUAL] "
	172	+	}
170	173		if total > 0 {
171	174		text += strconvItoa(m.Cursor+1) + "/" + strconvItoa(total) + " "
172	175		} else {

 // specific continuation protocol is supported.
 const OSC52MaxPayloadBytes = 75_000
-// Snapshot is the copy-mode document: scrollback followed by the live screen.
+// Snapshot is the scrollback-mode document: scrollback followed by the live screen.
 type Snapshot struct {
 	Rows   [][]renderer.Cell
 	Width  int
 	return Snapshot{Rows: rows, Width: screen.Width, Height: screen.Height}
 }
-// Mode stores per-client copy-mode viewport and line-selection state.
+// Mode stores per-client scrollback viewport and line-selection state.
 type Mode struct {
 	ViewportTop int
 	Cursor      int
 	for i := range row {
 		row[i] = renderer.BlankCell()
 	}
-	text := " [COPY] "
+	text := " [SCROLL] "
+	if m.Selecting {
+		text = " [VISUAL] "
+	}
 	if total > 0 {
 		text += strconvItoa(m.Cursor+1) + "/" + strconvItoa(total) + " "
 	} else {

M internal/usecase/copy/mode_test.go +29 -1


@@ -13,7 +13,7 @@ func snapshot(lines []string, height int) Snapshot {
13	13		for i, line := range lines {
14	14		rows[i] = row(line)
15	15		}
16		-	return Snapshot{Rows: rows, Width: 8, Height: height}
	16	+	return Snapshot{Rows: rows, Width: 16, Height: height}
17	17		}
18	18
19	19		func TestCopyModeNavigationBounds(t *testing.T) {

@@ -129,6 +129,22 @@ func TestCopyModeAtBottomWithShortSnapshot(t *testing.T) {
129	129		}
130	130		}
131	131
	132	+	func TestScrollbackModeStatusDistinguishesPassiveAndVisual(t *testing.T) {
	133	+	s := snapshot([]string{"alpha ", "beta ", "gamma "}, 2)
	134	+	m := NewMode(s)
	135	+
	136	+	frame := m.Render(s)
	137	+	if got := frameText(frame.Row(s.Height)); !strings.Contains(got, "[SCROLL]") \|\| strings.Contains(got, "[COPY]") \|\| strings.Contains(got, "[VISUAL]") {
	138	+	t.Fatalf("passive status = %q, want [SCROLL] and no copy/visual label", got)
	139	+	}
	140	+
	141	+	m.ToggleSelection()
	142	+	frame = m.Render(s)
	143	+	if got := frameText(frame.Row(s.Height)); !strings.Contains(got, "[VISUAL]") \|\| strings.Contains(got, "[SCROLL]") {
	144	+	t.Fatalf("selection status = %q, want [VISUAL] and no [SCROLL]", got)
	145	+	}
	146	+	}
	147	+
132	148		func TestCopyModeSelectionPayloadAndInverse(t *testing.T) {
133	149		s := snapshot([]string{"alpha ", "beta ", "gamma "}, 2)
134	150		m := &Mode{ViewportTop: 0, Cursor: 0, Anchor: 0, Selecting: true}

@@ -145,6 +161,18 @@ func TestCopyModeSelectionPayloadAndInverse(t *testing.T) {
145	161		}
146	162		}
147	163
	164	+	func frameText(row []renderer.Cell) string {
	165	+	var b strings.Builder
	166	+	for _, c := range row {
	167	+	if c.Rune == 0 {
	168	+	b.WriteRune(' ')
	169	+	continue
	170	+	}
	171	+	b.WriteRune(c.Rune)
	172	+	}
	173	+	return b.String()
	174	+	}
	175	+
148	176		func TestCopyModeMoveWhileSelectingKeepsAnchorAndExtendsSelection(t *testing.T) {
149	177		s := snapshot([]string{"00", "01", "02", "03", "04", "05"}, 3)
150	178		m := NewMode(s)


@@ -13,7 +13,7 @@ func snapshot(lines []string, height int) Snapshot {
13		for i, line := range lines {	13		for i, line := range lines {
14		rows[i] = row(line)	14		rows[i] = row(line)
15		}	15		}
16	-	return Snapshot{Rows: rows, Width: 8, Height: height}	16	+	return Snapshot{Rows: rows, Width: 16, Height: height}
17		}	17		}
18			18
19		func TestCopyModeNavigationBounds(t *testing.T) {	19		func TestCopyModeNavigationBounds(t *testing.T) {

@@ -129,6 +129,22 @@ func TestCopyModeAtBottomWithShortSnapshot(t *testing.T) {
129		}	129		}
130		}	130		}
131			131
			132	+	func TestScrollbackModeStatusDistinguishesPassiveAndVisual(t *testing.T) {
			133	+	s := snapshot([]string{"alpha ", "beta ", "gamma "}, 2)
			134	+	m := NewMode(s)
			135	+
			136	+	frame := m.Render(s)
			137	+	if got := frameText(frame.Row(s.Height)); !strings.Contains(got, "[SCROLL]") \|\| strings.Contains(got, "[COPY]") \|\| strings.Contains(got, "[VISUAL]") {
			138	+	t.Fatalf("passive status = %q, want [SCROLL] and no copy/visual label", got)
			139	+	}
			140	+
			141	+	m.ToggleSelection()
			142	+	frame = m.Render(s)
			143	+	if got := frameText(frame.Row(s.Height)); !strings.Contains(got, "[VISUAL]") \|\| strings.Contains(got, "[SCROLL]") {
			144	+	t.Fatalf("selection status = %q, want [VISUAL] and no [SCROLL]", got)
			145	+	}
			146	+	}
			147	+
132		func TestCopyModeSelectionPayloadAndInverse(t *testing.T) {	148		func TestCopyModeSelectionPayloadAndInverse(t *testing.T) {
133		s := snapshot([]string{"alpha ", "beta ", "gamma "}, 2)	149		s := snapshot([]string{"alpha ", "beta ", "gamma "}, 2)
134		m := &Mode{ViewportTop: 0, Cursor: 0, Anchor: 0, Selecting: true}	150		m := &Mode{ViewportTop: 0, Cursor: 0, Anchor: 0, Selecting: true}

@@ -145,6 +161,18 @@ func TestCopyModeSelectionPayloadAndInverse(t *testing.T) {
145		}	161		}
146		}	162		}
147			163
			164	+	func frameText(row []renderer.Cell) string {
			165	+	var b strings.Builder
			166	+	for _, c := range row {
			167	+	if c.Rune == 0 {
			168	+	b.WriteRune(' ')
			169	+	continue
			170	+	}
			171	+	b.WriteRune(c.Rune)
			172	+	}
			173	+	return b.String()
			174	+	}
			175	+
148		func TestCopyModeMoveWhileSelectingKeepsAnchorAndExtendsSelection(t *testing.T) {	176		func TestCopyModeMoveWhileSelectingKeepsAnchorAndExtendsSelection(t *testing.T) {
149		s := snapshot([]string{"00", "01", "02", "03", "04", "05"}, 3)	177		s := snapshot([]string{"00", "01", "02", "03", "04", "05"}, 3)
150		m := NewMode(s)	178		m := NewMode(s)

M internal/usecase/daemon/daemon.go +52 -15


@@ -170,6 +170,7 @@ type attachedClient struct {
170	170		copyMu sync.Mutex
171	171		copyMode *scopy.Mode
172	172		copyPending []byte
	173	+	copyFeedback string
173	174		pickerMu sync.Mutex
174	175		picker *picker.Model
175	176		pickerPreview *tab

@@ -225,18 +226,28 @@ func (ac *attachedClient) send(f ports.Frame) error {
225	226		// write. Detach/kill/shutdown paths use this so they are never gated on a
226	227		// client that has stopped draining its socket.
227	228		func (d Daemon) boundedSend(ac attachedClient, f ports.Frame) {
	229	+	_ = d.boundedSendErr(ac, f)
	230	+	}
	231	+
	232	+	func (d Daemon) boundedSendErr(ac attachedClient, f ports.Frame) error {
228	233		timer := d.clock.NewTimer(detachNotifyTimeout)
229		-	sent := make(chan struct{})
	234	+	result := make(chan error, 1)
230	235		go func() {
	236	+	result <- ac.send(f)
	237	+	}()
	238	+	select {
	239	+	case err := <-result:
	240	+	timer.Stop()
	241	+	return err
	242	+	case <-timer.C():
231	243		select {
232		-	case <-timer.C():
233		-	_ = ac.tr.Close()
234		-	case <-sent:
	244	+	case err := <-result:
	245	+	return err
	246	+	default:
235	247		}
236		-	}()
237		-	_ = ac.send(f)
238		-	timer.Stop()
239		-	close(sent)
	248	+	_ = ac.tr.Close()
	249	+	return errors.New("send timed out")
	250	+	}
240	251		}
241	252
242	253		// notifyDetachedAsync delivers a best-effort Detached notice off the caller's

@@ -946,12 +957,20 @@ func (d Daemon) handleCopyInput(ac attachedClient, data []byte) {
946	957		tb.mu.Unlock()
947	958
948	959		if copyOut && text != "" {
949		-	for _, chunk := range scopy.OSC52(text) {
950		-	if err := ac.send(frameOutput(chunk)); err != nil {
	960	+	chunks := scopy.OSC52(text)
	961	+	for _, chunk := range chunks {
	962	+	if err := d.boundedSendErr(ac, frameOutput(chunk)); err != nil {
951	963		d.detachOnSendError(sess, ac)
952	964		return
953	965		}
954	966		}
	967	+	ac.copyMu.Lock()
	968	+	if len(chunks) > 0 {
	969	+	ac.copyFeedback = "copied " + strconv.Itoa(len([]rune(text))) + " chars to clipboard"
	970	+	} else {
	971	+	ac.copyFeedback = "selection too large to copy"
	972	+	}
	973	+	ac.copyMu.Unlock()
955	974		}
956	975		if exit {
957	976		d.paint(sess, ac, true)

@@ -1619,7 +1638,15 @@ func (d Daemon) paint(sess session, ac *attachedClient, reset bool) {
1619	1638		ac.sendMu.Lock()
1620	1639		ac.copyMu.Lock()
1621	1640		copyActive := ac.copyMode != nil
1622		-	copyMode := ac.copyMode
	1641	+	var copyMode *scopy.Mode
	1642	+	if ac.copyMode != nil {
	1643	+	copyModeValue := *ac.copyMode
	1644	+	copyMode = &copyModeValue
	1645	+	}
	1646	+	copyFeedback := ac.copyFeedback
	1647	+	if copyFeedback != "" && !copyActive {
	1648	+	ac.copyFeedback = ""
	1649	+	}
1623	1650		ac.copyMu.Unlock()
1624	1651		ac.pickerMu.Lock()
1625	1652		pickerActive := ac.picker != nil

@@ -1634,7 +1661,7 @@ func (d Daemon) paint(sess session, ac *attachedClient, reset bool) {
1634	1661		if reset \|\| pickerActive {
1635	1662		ac.lastCursor.valid = false
1636	1663		}
1637		-	frame, damage := composeClientFrame(sess, tb, reset)
	1664	+	frame, damage := composeClientFrame(sess, tb, reset, copyFeedback)
1638	1665		if copyActive {
1639	1666		frame, damage = composeCopyClientFrame(copyMode, tb)
1640	1667		}

@@ -1712,13 +1739,13 @@ func (ac *attachedClient) encodeCursorTail(desired cursorOut, force bool) []byte
1712	1739		return b
1713	1740		}
1714	1741
1715		-	func composeClientFrame(sess session, tb tab, full bool) (renderer.Frame, []renderer.Damage) {
	1742	+	func composeClientFrame(sess session, tb tab, full bool, rightStatus string) (renderer.Frame, []renderer.Damage) {
1716	1743		width, screenRows := tb.screen.Frame.Width, tb.screen.Frame.Height
1717	1744		frame := renderer.NewFrame(width, screenRows+1)
1718	1745		for y := range screenRows {
1719	1746		copy(frame.Row(y), tb.screen.Frame.Row(y))
1720	1747		}
1721		-	drawStatus(frame.Row(screenRows), sess)
	1748	+	drawStatus(frame.Row(screenRows), sess, rightStatus)
1722	1749		if full {
1723	1750		return frame, []renderer.Damage{renderer.FullRedraw()}
1724	1751		}

@@ -1761,7 +1788,7 @@ func pickerPreviewFromLockedTab(tb *tab) picker.Preview {
1761	1788		return picker.Preview{Rows: rows, Width: tb.screen.Frame.Width, Height: tb.screen.Frame.Height}
1762	1789		}
1763	1790
1764		-	func drawStatus(row []renderer.Cell, sess *session) {
	1791	+	func drawStatus(row []renderer.Cell, sess *session, rightText string) {
1765	1792		for i := range row {
1766	1793		row[i] = renderer.BlankCell()
1767	1794		}

@@ -1775,6 +1802,16 @@ func drawStatus(row []renderer.Cell, sess *session) {
1775	1802		}
1776	1803		writeStatusText(row, &x, " "+w.name+" ", style)
1777	1804		}
	1805	+	if rightText == "" {
	1806	+	return
	1807	+	}
	1808	+	style := renderer.DefaultStyle()
	1809	+	rightWidth := len([]rune(rightText)) + 1
	1810	+	if len(row)-x-1 < rightWidth {
	1811	+	return
	1812	+	}
	1813	+	x = len(row) - rightWidth
	1814	+	writeStatusText(row, &x, " "+rightText, style)
1778	1815		}
1779	1816
1780	1817		type statusSnapshot struct {

 	copyMu        sync.Mutex
 	copyMode      *scopy.Mode
 	copyPending   []byte
+	copyFeedback  string
 	pickerMu      sync.Mutex
 	picker        *picker.Model
 	pickerPreview *tab
 // write. Detach/kill/shutdown paths use this so they are never gated on a
 // client that has stopped draining its socket.
 func (d *Daemon) boundedSend(ac *attachedClient, f ports.Frame) {
+	_ = d.boundedSendErr(ac, f)
+}
+func (d *Daemon) boundedSendErr(ac *attachedClient, f ports.Frame) error {
 	timer := d.clock.NewTimer(detachNotifyTimeout)
-	sent := make(chan struct{})
+	result := make(chan error, 1)
 	go func() {
+		result <- ac.send(f)
+	}()
+	select {
+	case err := <-result:
+		timer.Stop()
+		return err
+	case <-timer.C():
 		select {
-		case <-timer.C():
+		case err := <-result:
-			_ = ac.tr.Close()
+			return err
-		case <-sent:
+		default:
 		}
-	}()
+		_ = ac.tr.Close()
-	_ = ac.send(f)
+		return errors.New("send timed out")
-	timer.Stop()
+	}
-	close(sent)
 }
 // notifyDetachedAsync delivers a best-effort Detached notice off the caller's
 	tb.mu.Unlock()
 	if copyOut && text != "" {
-		for _, chunk := range scopy.OSC52(text) {
+		chunks := scopy.OSC52(text)
-			if err := ac.send(frameOutput(chunk)); err != nil {
+		for _, chunk := range chunks {
+			if err := d.boundedSendErr(ac, frameOutput(chunk)); err != nil {
 				d.detachOnSendError(sess, ac)
 				return
 			}
 		}
+		ac.copyMu.Lock()
+		if len(chunks) > 0 {
+			ac.copyFeedback = "copied " + strconv.Itoa(len([]rune(text))) + " chars to clipboard"
+		} else {
+			ac.copyFeedback = "selection too large to copy"
+		}
+		ac.copyMu.Unlock()
 	}
 	if exit {
 		d.paint(sess, ac, true)
 	ac.sendMu.Lock()
 	ac.copyMu.Lock()
 	copyActive := ac.copyMode != nil
-	copyMode := ac.copyMode
+	var copyMode *scopy.Mode
+	if ac.copyMode != nil {
+		copyModeValue := *ac.copyMode
+		copyMode = &copyModeValue
+	}
+	copyFeedback := ac.copyFeedback
+	if copyFeedback != "" && !copyActive {
+		ac.copyFeedback = ""
+	}
 	ac.copyMu.Unlock()
 	ac.pickerMu.Lock()
 	pickerActive := ac.picker != nil
 	if reset || pickerActive {
 		ac.lastCursor.valid = false
 	}
-	frame, damage := composeClientFrame(sess, tb, reset)
+	frame, damage := composeClientFrame(sess, tb, reset, copyFeedback)
 	if copyActive {
 		frame, damage = composeCopyClientFrame(copyMode, tb)
 	}
 	return b
 }
-func composeClientFrame(sess *session, tb *tab, full bool) (renderer.Frame, []renderer.Damage) {
+func composeClientFrame(sess *session, tb *tab, full bool, rightStatus string) (renderer.Frame, []renderer.Damage) {
 	width, screenRows := tb.screen.Frame.Width, tb.screen.Frame.Height
 	frame := renderer.NewFrame(width, screenRows+1)
 	for y := range screenRows {
 		copy(frame.Row(y), tb.screen.Frame.Row(y))
 	}
-	drawStatus(frame.Row(screenRows), sess)
+	drawStatus(frame.Row(screenRows), sess, rightStatus)
 	if full {
 		return frame, []renderer.Damage{renderer.FullRedraw()}
 	}
 	return picker.Preview{Rows: rows, Width: tb.screen.Frame.Width, Height: tb.screen.Frame.Height}
 }
-func drawStatus(row []renderer.Cell, sess *session) {
+func drawStatus(row []renderer.Cell, sess *session, rightText string) {
 	for i := range row {
 		row[i] = renderer.BlankCell()
 	}
 		}
 		writeStatusText(row, &x, " "+w.name+" ", style)
 	}
+	if rightText == "" {
+		return
+	}
+	style := renderer.DefaultStyle()
+	rightWidth := len([]rune(rightText)) + 1
+	if len(row)-x-1 < rightWidth {
+		return
+	}
+	x = len(row) - rightWidth
+	writeStatusText(row, &x, " "+rightText, style)
 }
 type statusSnapshot struct {

M internal/usecase/daemon/daemon_test.go +72 -10


@@ -306,7 +306,7 @@ func testRow(text string) []renderer.Cell {
306	306		return cells
307	307		}
308	308
309		-	func TestCopyModeAltUInterceptsAndDoesNotForward(t *testing.T) {
	309	+	func TestScrollbackModeAltUInterceptsAndDoesNotForward(t *testing.T) {
310	310		writes := make(chan []byte, 1)
311	311		p, _ := newBlockingPTYWithWrites(t, writes)
312	312		d, sess, ac, sends := newManualSessionWithPTYs(t, p)

@@ -316,18 +316,26 @@ func TestCopyModeAltUInterceptsAndDoesNotForward(t *testing.T) {
316	316		d.handleInput(sess, ac, []byte("\x1bu"))
317	317
318	318		if ac.copyMode == nil {
319		-	t.Fatal("copy mode not entered")
	319	+	t.Fatal("scrollback mode not entered")
320	320		}
321	321		select {
322	322		case got := <-writes:
323		-	t.Fatalf("copy-mode binding forwarded to PTY: %q", got)
	323	+	t.Fatalf("scrollback binding forwarded to PTY: %q", got)
324	324		default:
325	325		}
326	326		out := awaitFrame(t, sends, ports.MsgOutput)
327	327		msg, err := ports.UnmarshalOutput(out.Payload)
328	328		require.NoError(t, err)
329		-	if !strings.Contains(string(msg.Data), "[COPY]") {
330		-	t.Fatalf("copy mode paint = %q, want [COPY] status", string(msg.Data))
	329	+	if got := string(msg.Data); !strings.Contains(got, "[SCROLL]") \|\| strings.Contains(got, "[COPY]") {
	330	+	t.Fatalf("scrollback mode paint = %q, want [SCROLL] without [COPY]", got)
	331	+	}
	332	+
	333	+	d.handleInput(sess, ac, []byte(" "))
	334	+	out = awaitFrame(t, sends, ports.MsgOutput)
	335	+	msg, err = ports.UnmarshalOutput(out.Payload)
	336	+	require.NoError(t, err)
	337	+	if got := string(msg.Data); !strings.Contains(got, "[VISUAL]") \|\| strings.Contains(got, "[SCROLL]") {
	338	+	t.Fatalf("visual selection paint = %q, want [VISUAL] without [SCROLL]", got)
331	339		}
332	340		}
333	341

@@ -361,12 +369,23 @@ func TestCopyModeInputNotForwardedAndOSC52Copy(t *testing.T) {
361	369		live := awaitFrame(t, sends, ports.MsgOutput)
362	370		liveMsg, err := ports.UnmarshalOutput(live.Payload)
363	371		require.NoError(t, err)
364		-	if strings.Contains(string(liveMsg.Data), "[COPY]") {
365		-	t.Fatalf("live repaint still contains copy status: %q", string(liveMsg.Data))
	372	+	if strings.Contains(string(liveMsg.Data), "[COPY]") \|\| strings.Contains(string(liveMsg.Data), "[SCROLL]") {
	373	+	t.Fatalf("live repaint still contains copy/scroll status: %q", string(liveMsg.Data))
	374	+	}
	375	+	if !strings.Contains(string(liveMsg.Data), "copied 9 chars to clipboard") {
	376	+	t.Fatalf("live repaint = %q, want copy success feedback", string(liveMsg.Data))
366	377		}
367	378		if !strings.Contains(string(liveMsg.Data), "live") {
368	379		t.Fatalf("live repaint = %q, want live screen", string(liveMsg.Data))
369	380		}
	381	+
	382	+	d.paint(sess, ac, true)
	383	+	followup := awaitFrame(t, sends, ports.MsgOutput)
	384	+	followupMsg, err := ports.UnmarshalOutput(followup.Payload)
	385	+	require.NoError(t, err)
	386	+	if strings.Contains(string(followupMsg.Data), "copied 9 chars to clipboard") {
	387	+	t.Fatalf("copy feedback persisted after next repaint: %q", string(followupMsg.Data))
	388	+	}
370	389		}
371	390
372	391		func TestScrollbackEvictionFeedsCopyModeYank(t *testing.T) {

@@ -494,6 +513,29 @@ func TestCopyModeSplitArrowDoesNotExit(t *testing.T) {
494	513		}
495	514		}
496	515
	516	+	func TestCopyModeOversizedYankShowsTooLargeFeedback(t *testing.T) {
	517	+	p, _ := newBlockingPTY(t)
	518	+	d, sess, ac, sends := newManualSessionWithPTYs(t, p)
	519	+	sess.tabs[0].scrollback = scopy.NewScrollback(1)
	520	+	longLine := strings.Repeat("x", scopy.OSC52MaxPayloadBytes+1)
	521	+	sess.tabs[0].screen.Frame = renderer.NewFrame(len(longLine), 1)
	522	+	copy(sess.tabs[0].screen.Frame.Row(0), testRow(longLine))
	523	+
	524	+	d.enterCopyMode(sess, ac)
	525	+	awaitFrame(t, sends, ports.MsgOutput)
	526	+	d.handleInput(sess, ac, []byte{' ', 'y'})
	527	+
	528	+	out := awaitFrame(t, sends, ports.MsgOutput)
	529	+	msg, err := ports.UnmarshalOutput(out.Payload)
	530	+	require.NoError(t, err)
	531	+	if strings.Contains(string(msg.Data), "\x1b]52;") {
	532	+	t.Fatalf("oversized yank emitted OSC52: %q", string(msg.Data))
	533	+	}
	534	+	if !strings.Contains(string(msg.Data), "selection too large to copy") {
	535	+	t.Fatalf("oversized yank repaint = %q, want too-large feedback", string(msg.Data))
	536	+	}
	537	+	}
	538	+
497	539		func TestCopyModeEmptyYankDoesNotClearClipboard(t *testing.T) {
498	540		cases := []struct {
499	541		name string

@@ -1185,7 +1227,7 @@ func TestStatusCompositionGolden(t *testing.T) {
1185	1227		win.size = domain.Size{Cols: 12, Rows: 2}
1186	1228		win.screen.Write([]byte("hello"))
1187	1229
1188		-	frame, damage := composeClientFrame(sess, win, true)
	1230	+	frame, damage := composeClientFrame(sess, win, true, "")
1189	1231
1190	1232		require.Equal(t, 12, frame.Width)
1191	1233		require.Equal(t, 3, frame.Height)

@@ -1199,6 +1241,25 @@ func TestStatusCompositionGolden(t *testing.T) {
1199	1241		}
1200	1242		}
1201	1243
	1244	+	func TestStatusCopyFeedbackRendersOnlyWhenFullyFits(t *testing.T) {
	1245	+	p, releasePTY := newBlockingPTY(t)
	1246	+	_, sess, _, _ := newManualSessionWithPTYs(t, p)
	1247	+	defer releasePTY()
	1248	+	sess.name = "work"
	1249	+	win := sess.activeTab()
	1250	+	win.screen = vt.NewScreen(30, 2)
	1251	+	win.size = domain.Size{Cols: 30, Rows: 2}
	1252	+
	1253	+	frame, _ := composeClientFrame(sess, win, true, "ok")
	1254	+	require.Equal(t, " work 1 ok", rowText(frame.Row(2)))
	1255	+
	1256	+	frame, _ = composeClientFrame(sess, win, true, "1234567890123456789")
	1257	+	require.Equal(t, " work 1 1234567890123456789", rowText(frame.Row(2)))
	1258	+
	1259	+	frame, _ = composeClientFrame(sess, win, true, "selection too large to copy")
	1260	+	require.Equal(t, " work 1 ", rowText(frame.Row(2)))
	1261	+	}
	1262	+
1202	1263		func TestStatusRepaintsOnCreateSwitchAndResize(t *testing.T) {
1203	1264		p1, releasePTY1 := newBlockingPTY(t)
1204	1265		p2, releasePTY2 := newBlockingPTY(t)

@@ -2013,7 +2074,7 @@ func mustOutputData(t *testing.T, sends chan ports.Frame) []byte {
2013	2074		return out.Data
2014	2075		}
2015	2076
2016		-	func TestMouseWheelCopyEntryExitAndStreamOrder(t *testing.T) {
	2077	+	func TestMouseWheelEntersScrollbackModeAndExitsAtBottom(t *testing.T) {
2017	2078		writes := make(chan []byte, 4)
2018	2079		p, _ := newBlockingPTYWithWrites(t, writes)
2019	2080		d, sess, ac, sends := newManualSessionWithPTYs(t, p)

@@ -2021,9 +2082,10 @@ func TestMouseWheelCopyEntryExitAndStreamOrder(t *testing.T) {
2021	2082		win.screen.Write([]byte("live"))
2022	2083
2023	2084		d.handleInput(sess, ac, []byte("\x1b[<64;1;1M"))
2024		-	mustOutputData(t, sends)
	2085	+	data := mustOutputData(t, sends)
2025	2086		require.NotNil(t, ac.copyMode)
2026	2087		require.Equal(t, 19, ac.copyMode.Cursor)
	2088	+	require.Contains(t, string(data), "[SCROLL]")
2027	2089
2028	2090		d.handleInput(sess, ac, []byte("\x1b[<65;1;1M"))
2029	2091		mustOutputData(t, sends)

 	return cells
 }
-func TestCopyModeAltUInterceptsAndDoesNotForward(t *testing.T) {
+func TestScrollbackModeAltUInterceptsAndDoesNotForward(t *testing.T) {
 	writes := make(chan []byte, 1)
 	p, _ := newBlockingPTYWithWrites(t, writes)
 	d, sess, ac, sends := newManualSessionWithPTYs(t, p)
 	d.handleInput(sess, ac, []byte("\x1bu"))
 	if ac.copyMode == nil {
-		t.Fatal("copy mode not entered")
+		t.Fatal("scrollback mode not entered")
 	}
 	select {
 	case got := <-writes:
-		t.Fatalf("copy-mode binding forwarded to PTY: %q", got)
+		t.Fatalf("scrollback binding forwarded to PTY: %q", got)
 	default:
 	}
 	out := awaitFrame(t, sends, ports.MsgOutput)
 	msg, err := ports.UnmarshalOutput(out.Payload)
 	require.NoError(t, err)
-	if !strings.Contains(string(msg.Data), "[COPY]") {
+	if got := string(msg.Data); !strings.Contains(got, "[SCROLL]") || strings.Contains(got, "[COPY]") {
-		t.Fatalf("copy mode paint = %q, want [COPY] status", string(msg.Data))
+		t.Fatalf("scrollback mode paint = %q, want [SCROLL] without [COPY]", got)
+	}
+	d.handleInput(sess, ac, []byte(" "))
+	out = awaitFrame(t, sends, ports.MsgOutput)
+	msg, err = ports.UnmarshalOutput(out.Payload)
+	require.NoError(t, err)
+	if got := string(msg.Data); !strings.Contains(got, "[VISUAL]") || strings.Contains(got, "[SCROLL]") {
+		t.Fatalf("visual selection paint = %q, want [VISUAL] without [SCROLL]", got)
 	}
 }
 	live := awaitFrame(t, sends, ports.MsgOutput)
 	liveMsg, err := ports.UnmarshalOutput(live.Payload)
 	require.NoError(t, err)
-	if strings.Contains(string(liveMsg.Data), "[COPY]") {
+	if strings.Contains(string(liveMsg.Data), "[COPY]") || strings.Contains(string(liveMsg.Data), "[SCROLL]") {
-		t.Fatalf("live repaint still contains copy status: %q", string(liveMsg.Data))
+		t.Fatalf("live repaint still contains copy/scroll status: %q", string(liveMsg.Data))
+	}
+	if !strings.Contains(string(liveMsg.Data), "copied 9 chars to clipboard") {
+		t.Fatalf("live repaint = %q, want copy success feedback", string(liveMsg.Data))
 	}
 	if !strings.Contains(string(liveMsg.Data), "live") {
 		t.Fatalf("live repaint = %q, want live screen", string(liveMsg.Data))
 	}
+	d.paint(sess, ac, true)
+	followup := awaitFrame(t, sends, ports.MsgOutput)
+	followupMsg, err := ports.UnmarshalOutput(followup.Payload)
+	require.NoError(t, err)
+	if strings.Contains(string(followupMsg.Data), "copied 9 chars to clipboard") {
+		t.Fatalf("copy feedback persisted after next repaint: %q", string(followupMsg.Data))
+	}
 }
 func TestScrollbackEvictionFeedsCopyModeYank(t *testing.T) {
 	}
 }
+func TestCopyModeOversizedYankShowsTooLargeFeedback(t *testing.T) {
+	p, _ := newBlockingPTY(t)
+	d, sess, ac, sends := newManualSessionWithPTYs(t, p)
+	sess.tabs[0].scrollback = scopy.NewScrollback(1)
+	longLine := strings.Repeat("x", scopy.OSC52MaxPayloadBytes+1)
+	sess.tabs[0].screen.Frame = renderer.NewFrame(len(longLine), 1)
+	copy(sess.tabs[0].screen.Frame.Row(0), testRow(longLine))
+	d.enterCopyMode(sess, ac)
+	awaitFrame(t, sends, ports.MsgOutput)
+	d.handleInput(sess, ac, []byte{' ', 'y'})
+	out := awaitFrame(t, sends, ports.MsgOutput)
+	msg, err := ports.UnmarshalOutput(out.Payload)
+	require.NoError(t, err)
+	if strings.Contains(string(msg.Data), "\x1b]52;") {
+		t.Fatalf("oversized yank emitted OSC52: %q", string(msg.Data))
+	}
+	if !strings.Contains(string(msg.Data), "selection too large to copy") {
+		t.Fatalf("oversized yank repaint = %q, want too-large feedback", string(msg.Data))
+	}
+}
 func TestCopyModeEmptyYankDoesNotClearClipboard(t *testing.T) {
 	cases := []struct {
 		name  string
 	win.size = domain.Size{Cols: 12, Rows: 2}
 	win.screen.Write([]byte("hello"))
-	frame, damage := composeClientFrame(sess, win, true)
+	frame, damage := composeClientFrame(sess, win, true, "")
 	require.Equal(t, 12, frame.Width)
 	require.Equal(t, 3, frame.Height)
 	}
 }
+func TestStatusCopyFeedbackRendersOnlyWhenFullyFits(t *testing.T) {
+	p, releasePTY := newBlockingPTY(t)
+	_, sess, _, _ := newManualSessionWithPTYs(t, p)
+	defer releasePTY()
+	sess.name = "work"
+	win := sess.activeTab()
+	win.screen = vt.NewScreen(30, 2)
+	win.size = domain.Size{Cols: 30, Rows: 2}
+	frame, _ := composeClientFrame(sess, win, true, "ok")
+	require.Equal(t, " work  1                    ok", rowText(frame.Row(2)))
+	frame, _ = composeClientFrame(sess, win, true, "1234567890123456789")
+	require.Equal(t, " work  1   1234567890123456789", rowText(frame.Row(2)))
+	frame, _ = composeClientFrame(sess, win, true, "selection too large to copy")
+	require.Equal(t, " work  1                      ", rowText(frame.Row(2)))
+}
 func TestStatusRepaintsOnCreateSwitchAndResize(t *testing.T) {
 	p1, releasePTY1 := newBlockingPTY(t)
 	p2, releasePTY2 := newBlockingPTY(t)
 	return out.Data
 }
-func TestMouseWheelCopyEntryExitAndStreamOrder(t *testing.T) {
+func TestMouseWheelEntersScrollbackModeAndExitsAtBottom(t *testing.T) {
 	writes := make(chan []byte, 4)
 	p, _ := newBlockingPTYWithWrites(t, writes)
 	d, sess, ac, sends := newManualSessionWithPTYs(t, p)
 	win.screen.Write([]byte("live"))
 	d.handleInput(sess, ac, []byte("\x1b[<64;1;1M"))
-	mustOutputData(t, sends)
+	data := mustOutputData(t, sends)
 	require.NotNil(t, ac.copyMode)
 	require.Equal(t, 19, ac.copyMode.Cursor)
+	require.Contains(t, string(data), "[SCROLL]")
 	d.handleInput(sess, ac, []byte("\x1b[<65;1;1M"))
 	mustOutputData(t, sends)