Fix four regressions from the density pass

Separating "which message does this run BELONG to" from "does it indent
under that message" is the root fix for the first three: I had collapsed
both onto one variable, so refusing to indent under your message also
took away the run's owner.

- a turn-opening run belongs to your message again, so → opens it and ←
  steps back out; it just doesn't branch off it visually
- opening a long user message no longer unfolds the run below it as a
  side effect of un-clamping the text
- a flat fold still wears ⎿, not the ✦ infrastructure mark
- the ▶ falls to the topmost VISIBLE row of the selected block: with no
  highlight bar left, a block taller than the window showed no cursor

Author: hbrooks

src/ui/ConnectApp.tsx

@@ -979,14 +979,21 @@ export function ConnectApp(props: ConnectAppProps): React.ReactElement {
     return rowViewport(allRows.length, viewBudget, anchor)
   }, [allRows, viewBudget, scrollAnchor])
 
-  // The one row that wears the ▶ marker: the highlighted block's FIRST row with
-  // a gutter glyph. The whole block tints, but the marker points at a single
-  // line — a block with nested tool activity has a glyph on the call and on its
-  // ⎿ result, and marking both reads as two separate selections.
+  // The one row that wears the ▶ marker: the selected block's FIRST row with a
+  // gutter glyph, since the marker replaces that glyph in place. Only one row
+  // takes it — a block with nested tool activity has a glyph on the call and on
+  // its ⎿ result, and marking both reads as two separate selections.
+  //
+  // Restricted to rows ON SCREEN, because the marker is now the ONLY thing that
+  // says "you are here" (there is no highlight bar any more). A block taller
+  // than the window is bottom-aligned by the ↑ snap, which puts its first row
+  // above the frame — so the marker falls to the topmost visible row of the
+  // block, and the selection stays legible instead of vanishing.
   const markerRowId = useMemo(() => {
     if (navKey === null) return null
-    return allRows.find((r) => navKeyOf(r) === navKey && r.gutter)?.id ?? null
-  }, [allRows, navKey])
+    const onScreen = allRows.slice(view.start, view.end).filter((r) => navKeyOf(r) === navKey)
+    return (onScreen.find((r) => r.gutter) ?? onScreen.find((r) => !r.spacer))?.id ?? null
+  }, [allRows, navKey, view.start, view.end])
 
   // Move the window by `delta` ROWS. Reaching the last row re-pins it to the
   // bottom, so streamed content follows again.

src/ui/transcriptRows.ts

@@ -210,10 +210,11 @@ export function itemRows(
   const indent = opts.indent ?? 0
   // Nested lines are marked by their INDENT, so each keeps the glyph that says
   // what it is: ● the call, ⎿ the result that came back. Only a collapsed fold
-  // ("Ran 2 tool calls") takes the branch glyph — as a notice it would
-  // otherwise wear ✦, the mark for the infrastructure speaking, which is not
-  // what a fold is.
-  const gutter = opts.nested && item.kind === 'notice' ? BRANCH_GLYPH : gutterFor(item)
+  // (key grp:*, "Ran 2 tool calls") takes the branch glyph — as a notice it
+  // would otherwise wear ✦, the mark for the infrastructure speaking, which is
+  // not what a fold is. Keyed on the fold itself, not on `nested`: a
+  // turn-opening run is flat, and it is still a fold.
+  const gutter = item.key.startsWith('grp:') ? BRANCH_GLYPH : gutterFor(item)
   const textPad = gutter === BRANCH_GLYPH ? BRANCH_TEXT_PAD : 0
   const width = contentWidth(cols, { indent, textPad })
   const shown = withRenderedMarkdown(item, width)
@@ -270,14 +271,18 @@ export function itemRows(
 // glyph, attached with no blank row between. Prose, user messages and notices
 // keep their own gutter mark and their spacing.
 //
-// The parent is always an ASSISTANT message. A run with none before it (the
-// agent opened its turn with a tool call) stays FLAT rather than hanging off
-// the user message that prompted it: your message is a lifted box, and a ⎿
-// branch under it would read as work YOU did.
+// INDENT and OWNERSHIP are decided separately, because they answer different
+// questions. A run belongs to (is opened by, travels with) whatever message
+// came last, YOURS INCLUDED — the agent often opens a turn with a tool call,
+// and a run that belonged to nothing could not be reached with →. But it only
+// INDENTS under assistant prose: your message is a lifted box, and a ⎿ branch
+// under it would read as work YOU did, so a turn-opening run stays flat and
+// separated by its own blank row. Only a run at the very top of the transcript,
+// with no message above it at all, belongs to nothing.
 //
-// Nesting also decides what ↑/↓ can LAND on, because a tool call is not a stop
-// of its own — it belongs to the message that made it. Three levels, each
-// opened by → on the level above:
+// Ownership is what ↑/↓ can LAND on, because a tool call is not a stop of its
+// own — it belongs to the message that made it. Three levels, each opened by →
+// on the level above:
 //
 //   ● the message            a stop; ↑/↓ walk these
 //     ⎿ Ran 3 tool calls     part of the message's block (navKey → the message)
@@ -309,19 +314,23 @@ export function layOutItems(
   opts: { openedKeys?: ReadonlySet<string>; revealAll?: boolean } = {},
 ): PlacedItem[] {
   const out: PlacedItem[] = []
-  // The ASSISTANT message the current run hangs off — null until the agent has
-  // said something, where a run has nothing to hang off and stays flat.
+  // The message the current run BELONGS to — what → opens and ↑/↓ land on.
+  // Either sender's; null only at the head of the transcript.
   let parent: string | null = null
+  // Whether that message was the agent's, which is what decides the visual
+  // nesting: only the agent's prose gets a ⎿ branch under it.
+  let parentIsAgent = false
   // The call a ⎿ result belongs to, so a result travels with its own call.
   let call: string | null = null
   for (const item of items) {
     if (!isToolActivity(item)) {
       out.push({ item, indent: 0, nested: false, attach: false })
-      parent = item.kind === 'assistant' ? item.key : null
+      parent = item.key
+      parentIsAgent = item.kind === 'assistant'
       call = null
       continue
     }
-    const nested = parent !== null
+    const nested = parent !== null && parentIsAgent
     const revealed =
       opts.revealAll === true || (parent !== null && opts.openedKeys?.has(parent) === true)
     if (item.kind === 'tool') call = item.key

test/connect-app.test.ts

@@ -561,6 +561,14 @@ describe('layOutItems', () => {
     ])
   })
 
+  it('still lets that flat run BELONG to your message, so → can open it', () => {
+    // Indent and ownership are separate: the run doesn't branch off your
+    // message visually, but it is reached by opening it. Owning nothing would
+    // make the run unreachable without ctrl+r.
+    const out = layOutItems([user('u'), fold('t1')])
+    expect(out[1].navKey).toBe('u')
+  })
+
   it('leaves a run with no parent above it flat', () => {
     // Replayed history can start mid-burst; there is nothing to hang off.
     const out = layOutItems([call('t1'), res('r1'), prose('a')])
@@ -832,6 +840,27 @@ describe('itemRows', () => {
     expect(withGutter[0].gutter?.text).toBe('◆')
   })
 
+  it('marks a fold ⎿ whether or not it nests, since a flat one is still a fold', () => {
+    const foldItem: TranscriptItem = { key: 'grp:t1', kind: 'notice', text: 'Ran 1 shell command' }
+    for (const nested of [true, false]) {
+      const rows = itemRows(foldItem, 40, { clamp: false, nested })
+      expect(rows[0].gutter?.text, `nested=${nested}`).toBe('⎿')
+    }
+    // A real ✦ notice keeps its own mark either way.
+    const notice: TranscriptItem = { key: 'n', kind: 'notice', text: 'Session asleep' }
+    expect(itemRows(notice, 40, { clamp: false, nested: true })[0].gutter?.text).toBe('✦')
+  })
+
+  it('pads every row of a ⎿ item, so a wrapped body stays aligned', () => {
+    const rows = itemRows({ key: 'r', kind: 'tool_result', text: 'a\nb', gutter: '⎿' }, 40, {
+      clamp: false,
+    })
+    expect(rows.map((r) => r.textPad)).toEqual([1, 1])
+    // And nothing else gets it.
+    expect(itemRows({ key: 'a', kind: 'assistant', text: 'hi' }, 40, { clamp: false })[0].textPad)
+      .toBe(0)
+  })
+
   it('leads with a spacer row when the item wants space before it', () => {
     const rows = itemRows({ key: 'a', kind: 'notice', text: 'note', spaceBefore: true }, 40, {
       clamp: false,