merge: shell region + declarative transcript on ctml (lane/ctml-region)

Slice 7b on go-html v0.14.0's two levers. Region renders through
shellwide.ctml (HCRF, wide) / shellregion.ctml (HCF, single-pane) with
zero-chrome themes; the chat transcript is an each + row-scoped
verbatim (transcript.ctml) — the Builder accumulation loop deleted,
per-turn role branching factored host-side unchanged. Overlay-with-
inspector-open stays host-composed (HLCRF has no mid-page pair —
friction filed). Two doctrine-tied deltas: wide inspector 28 not 32
(fixed unexported termAsideWidth, pinned by
TestRegionAsideWidth_MatchesGoHTML), separator rule glyph → go-html's
own blank gutter (no theme hook). Round 5 items filed for both.

Gates: vet+build clean, 420 tui tests (floor 419, +1).

Co-Authored-By: Virgil <virgil@lethean.io>

Author: Snider

cli/tui/README.md

@@ -249,56 +249,78 @@ settings and the picker established.
 
 ### The app shell
 
-`layout.go` (`renderFrame` + `shell.ctml`) closes the migration at the
-outermost layer: the permanent frame every primary panel renders inside
-— tab strip, session strip, the active panel/overlay body, footer key
-hints, all inside one rounded border.
-
-- **A `<layout variant="HF">` band-split, not a full HLCRF page.** The
-  header (tab strip + session strip, already joined and each already
-  fitted to the frame's inner width) and the footer (status + key hints,
-  likewise pre-fitted) ride `<verbatim>` in the H and F slots;
-  `renderBandFrame` (the same HF idiom overlays and the Data list's live
-  filter input already use) splits the render at the H slot's own
-  recorded box height, and the host composes the region — the active main
-  panel, plus the wide/toggled inspector, `renderWorkspaceRegion` —
-  between the two bands, exactly as a widget-carrying overlay composes a
-  live Bubbles widget between its own bands.
-- **The Content slot is a dead end for full-width verbatim.** Unlike
-  Header/Footer/Sidebar/Aside, `renderTermContent` hardcodes a `(0,1)`
-  padding with no `TermTheme` override; content already fitted to the
-  slot's own width arrives one column too wide once that padding lands,
-  and the slot's own `Width()` enforcement word-wraps the overflow onto a
-  spurious extra row instead of leaving it byte-exact. `renderTermBox`
-  (Sidebar/Aside — L and R) carries the same defect through its own
-  hardcoded `-4`/`-2` offsets. H and F have no such tax — both route
-  through nothing but the (fully themeable, here stripped-to-blank)
-  `theme.Header`/`theme.Footer` style — so the region stays host-composed
-  and rides between the bands rather than through any middle-band slot.
-  `wideInspectorWidth`, `measureFrame`'s per-`layoutKind` maths, and
-  `renderWorkspaceRegion`'s wide/compact/narrow arrangements are therefore
-  unchanged: none of it is a rendering-composition concern .ctml can take
-  over, since the one slot that could hold it corrupts pre-fitted content,
-  and the arithmetic itself has nowhere to live in a language with no
-  operators (docs/ctml.md S:8.4).
-- **Mouse hit-testing needed no re-plumbing.** `onMouse` resolves against
-  its own independent `renderPanelBarBoxes` call, keyed off
-  `frameInsetRows`/`frameInsetCols` and the tab strip's row-0 position —
-  both unchanged by this slice, since the tab strip's own render path
-  (`renderPanelBar`, `tabs.ctml`) is untouched; it now merely arrives at
-  the shell as a pre-rendered value instead of a `JoinVertical` argument.
-- **The chat transcript stays hand-composed.** `renderTranscript`'s
-  turn-by-turn Glamour composition is a list whose row COUNT is unbounded
-  and whose per-row body is pre-styled ANSI — exactly the `<each>` +
-  per-row `<verbatim>` shape a transcript would need — but `<verbatim
-  value="key">` resolves `key` once against the document-wide
-  `Bindings.Values` at PARSE time (`ctml/parse.go`'s `parseVerbatim`), not
-  per row at render time the way a `{{path}}` bind does; every row inside
-  an `<each>` would render the identical fixed content. Converting the
-  transcript would need either an unbounded flat list of named verbatim
-  slots (impractical) or row-scoped verbatim resolution go-html does not
-  have yet (mirroring how `id="row-{{row.id}}"` already resolves per row
-  for box identification). Left unconverted, not silently skipped.
+`layout.go` (`renderFrame` + `shell.ctml`/`shellregion.ctml`/`shellwide.ctml`)
+closes the migration at the outermost layer: the permanent frame every
+primary panel renders inside — tab strip, session strip, the active
+panel/overlay body, footer key hints, all inside one rounded border.
+
+- **The header/footer bands are a `<layout variant="HF">` band-split** in
+  all three shell files alike. The header (tab strip + session strip,
+  already joined and each already fitted to the frame's inner width) and
+  the footer (status + key hints, likewise pre-fitted) ride `<verbatim>` in
+  the H and F slots.
+- **The region joins the same declarative surface as H/F for every shape
+  but one**, since go-html v0.14.0 shipped a themeable `Content` style
+  (`TermTheme.Content`, matching the pre-existing themeable `Aside`) and
+  row-scoped verbatim: a zero-chrome C (and R) now passes pre-fitted
+  content through byte-exact at the slot's full width, closing the gap the
+  previous round left open (docs/ctml.md S:15.2/S:15.5). Wide layouts
+  (`shellwide.ctml`, `<layout variant="HCRF">`) bind the main panel to C
+  and the inspector to R, one `RenderTerm` call (`renderBandLayout`) in
+  place of `lipgloss.JoinHorizontal` and a manual `│` separator column.
+  Every single-pane shape — Narrow either way, Overlay with the inspector
+  closed — binds the one active pane to C (`shellregion.ctml`,
+  `<layout variant="HCF">`), replacing a bare `fitPane` call. The ONE shape
+  that still cannot join them is Overlay with the inspector open: two
+  independently-sized panes stacked vertically with a rule between, which
+  HLCRF's five-letter slot vocabulary has no pair for (H/F are whole-page
+  top/bottom bands, not a reusable mid-page pair, and go-html's own
+  automatic L/C/R vertical stacking triggers only below 80 columns —
+  S:15.1 — above this layout kind's own floor). That one shape stays
+  exactly the pre-.ctml host composition: `shell.ctml`'s H/F-only layout,
+  split by `renderBandFrame`, with `renderInspectorStack` composing the
+  region between the bands — the same HF+host-composition idiom a
+  widget-carrying overlay uses for a live Bubbles widget between its own
+  bands.
+- **The Wide inspector is now 28 columns, not 32.** go-html's non-FitSlots
+  middle band gives R a fixed outer-width budget (the unexported
+  `termAsideWidth`, S:15.1) whenever R is present at ≥80 columns — there is
+  no `TermOptions`/`Layout` lever to request a different width, and a
+  zero-chrome C does not collapse the C/R junction either: go-html always
+  inserts its own single blank-space gutter before R, so the old visible
+  `│` rule is gone with it (the gutter is blank; there is no theme lever to
+  paint a glyph into it). `regionAsideWidth` (`layout.go`) mirrors the
+  fixed budget as a documented local constant — go-html exports no
+  accessor for it (S:15.5) — and `TestRegionAsideWidth_MatchesGoHTML` pins
+  it against a live `RenderTermBoxes` call so upstream drift fails loudly
+  rather than silently reflowing the frame. The main panel gains the 4
+  columns back (`measureFrame`'s Wide case); this is a real, visible width
+  delta, tied entirely to that one doctrine clause.
+- **Mouse hit-testing needed no re-plumbing, this slice included.**
+  `onMouse` resolves against its own independent `renderPanelBarBoxes`
+  call, keyed off `frameInsetRows`/`frameInsetCols` and the tab strip's
+  row-0 position — both unchanged since the tab strip's own render path
+  (`renderPanelBar`, `tabs.ctml`) is untouched. No region content (chat
+  transcript, Work/Data/Models/Service panels, the inspector) resolves a
+  mouse coordinate against its own composition today, so there was no
+  "old composition maths" to re-plumb onto boxes for this slice either.
+- **The chat transcript's row LIST is declarative; each row's own
+  STRUCTURE stays host-decided.** `transcript.ctml` is a zero-or-one-row
+  "notice" sequence (the session status banner) followed by one row per
+  turn, each row's verbatim `body` the turn's complete pre-formatted
+  output — row-scoped verbatim (`<verbatim value="{{turn.body}}"/>`,
+  materialised per row against the enclosing `<each>`, S:6.5) replaced the
+  old hand-grown `core.Builder` accumulation loop. What did NOT convert:
+  a turn's SHAPE (an inline "you "+text line for `user`, a label+result
+  pair for `tool`, or an optional thinking line + label + Glamour/streaming
+  body + tool calls + a live spinner for `assistant`) still branches in Go
+  (`renderTranscriptTurn`), because `<switch>`/`<if>`/`<unless>` compile to
+  a `func(*Context) bool/string` closure resolved once per RENDER against
+  `Context.Data` (S:7) — the same context for every row an `<each>`
+  produces, not a per-row scope the way a `{{path}}` bind is. A row can
+  vary its VALUES; it cannot vary its STRUCTURE. This is the documented
+  closed-vocabulary boundary (S:1.1: a named lookup, never an expression),
+  not a workaround.
 
 ### The command palette
 

cli/tui/app.go

@@ -4,6 +4,7 @@ package tui
 
 import (
 	"context"
+	_ "embed"
 	"sync"
 	"time"
 
@@ -16,11 +17,21 @@ import (
 	"github.com/charmbracelet/lipgloss"
 
 	core "dappco.re/go"
+	"dappco.re/go/html"
+	"dappco.re/go/html/ctml"
 	"dappco.re/go/inference"
 	"dappco.re/go/inference/dataset"
 	"dappco.re/go/inference/decode/parser"
 )
 
+// transcriptCTML is the chat panel's turn-list markup -- see transcript.ctml
+// for the row-scoped verbatim idiom it exposes and why per-turn STRUCTURE
+// stays host-decided (renderTranscriptTurn) while the row LIST itself is
+// declarative.
+//
+//go:embed transcript.ctml
+var transcriptCTML []byte
+
 // turn is one rendered element in the transcript.
 type turn struct {
 	id      string
@@ -3051,62 +3062,101 @@ func (a app) transcriptHeight() int {
 	return h
 }
 
+// renderTranscript renders transcript.ctml: a zero-or-one-row "notice"
+// sequence (the session status banner) followed by one row per turn, each
+// row's verbatim "body" the complete pre-formatted turn (renderTranscriptTurn)
+// -- go-html owns the row iteration and the byte-exact verbatim passthrough,
+// the host still owns every turn's own content (transcript.ctml's header
+// comment has the full account of why). A parse failure never happens
+// against this embedded, static markup outside a build defect (the same
+// assumption renderBandFrame/renderBandLayout make, overlayframe.go) and
+// degrades to an empty transcript rather than panicking.
 func (a app) renderTranscript() string {
-	var b core.Builder
+	tree, err := ctml.Parse(transcriptCTML, a.transcriptBindings())
+	if err != nil {
+		return ""
+	}
+	return lipgloss.NewStyle().Width(a.view.Width).Render(html.RenderTerm(tree, html.NewContext()))
+}
+
+// transcriptBindings supplies transcript.ctml's two row sequences. notice is
+// zero-or-one row so an absent banner renders nothing (not an empty line);
+// every turn row's own leadingBlank folds in the "\n" go-html's own
+// block-level join does not supply a second one of, reproducing the
+// original "\n\n" turn gap byte-for-byte (transcript.ctml's header comment).
+func (a app) transcriptBindings() ctml.Bindings {
 	notice := a.sessionTranscriptNotice()
+	var noticeRows []map[string]any
 	if notice != "" {
-		b.WriteString(a.styles.attention.Render(notice))
+		noticeRows = []map[string]any{{"text": a.styles.attention.Render(notice)}}
 	}
+	turnRows := make([]map[string]any, 0, len(a.turns))
 	for i, t := range a.turns {
-		if i > 0 || notice != "" {
-			b.WriteString("\n\n")
-		}
-		switch t.role {
-		case "user":
-			b.WriteString(a.styles.user.Render("you ") + a.styles.answer.Render(t.text))
-		case "tool":
-			label := "tool result"
-			if len(t.calls) > 0 {
-				label = core.Concat("tool · ", t.calls[0])
-			}
-			b.WriteString(a.styles.thought.Render(label))
-			if result := visibleToolResult(t.text); result != "" {
-				b.WriteString("\n" + a.styles.answer.Render(result))
-			}
-		default:
-			if t.thought != "" {
-				b.WriteString(a.styles.thought.Render("· thinking · "+core.Trim(t.thought)) + "\n")
-			}
-			label := t.model
-			if label == "" {
-				label = a.modelName
-			}
-			if label == "" {
-				label = "assistant"
-			}
-			b.WriteString(a.styles.assistant.Render(label))
-			streaming := a.generating && i == len(a.turns)-1
-			if t.text != "" {
-				b.WriteString("\n")
-				if streaming {
-					b.WriteString(a.styles.answer.Render(t.text))
-				} else {
-					turnID := t.id
-					if turnID == "" {
-						turnID = core.Sprintf("transcript-%d", i)
-					}
-					b.WriteString(a.markdown.Render(turnID, t.text, max(1, a.view.Width-2)))
+		leadingBlank := i > 0 || notice != ""
+		turnRows = append(turnRows, map[string]any{"body": a.renderTranscriptTurn(i, t, leadingBlank)})
+	}
+	return ctml.Bindings{Sequences: map[string][]map[string]any{
+		"notice": noticeRows,
+		"turns":  turnRows,
+	}}
+}
+
+// renderTranscriptTurn formats exactly one turn -- byte-for-byte what the
+// pre-.ctml renderTranscript loop wrote inline for the same turn, role
+// branching included (transcript.ctml's header comment explains why that
+// branching stays here rather than in markup). leadingBlank prepends the
+// single "\n" this row owes the inter-turn gap; blocks() (go-html) supplies
+// the other half of the "\n\n" via its own row-to-row join.
+func (a app) renderTranscriptTurn(i int, t turn, leadingBlank bool) string {
+	var b core.Builder
+	if leadingBlank {
+		b.WriteString("\n")
+	}
+	switch t.role {
+	case "user":
+		b.WriteString(a.styles.user.Render("you ") + a.styles.answer.Render(t.text))
+	case "tool":
+		label := "tool result"
+		if len(t.calls) > 0 {
+			label = core.Concat("tool · ", t.calls[0])
+		}
+		b.WriteString(a.styles.thought.Render(label))
+		if result := visibleToolResult(t.text); result != "" {
+			b.WriteString("\n" + a.styles.answer.Render(result))
+		}
+	default:
+		if t.thought != "" {
+			b.WriteString(a.styles.thought.Render("· thinking · "+core.Trim(t.thought)) + "\n")
+		}
+		label := t.model
+		if label == "" {
+			label = a.modelName
+		}
+		if label == "" {
+			label = "assistant"
+		}
+		b.WriteString(a.styles.assistant.Render(label))
+		streaming := a.generating && i == len(a.turns)-1
+		if t.text != "" {
+			b.WriteString("\n")
+			if streaming {
+				b.WriteString(a.styles.answer.Render(t.text))
+			} else {
+				turnID := t.id
+				if turnID == "" {
+					turnID = core.Sprintf("transcript-%d", i)
 				}
+				b.WriteString(a.markdown.Render(turnID, t.text, max(1, a.view.Width-2)))
 			}
-			for _, c := range t.calls {
-				b.WriteString("\n" + a.styles.thought.Render("→ "+c))
-			}
-			if t.text == "" && t.thought == "" && a.generating && i == len(a.turns)-1 {
-				b.WriteString(a.styles.thought.Render(a.spin.View() + " …"))
-			}
+		}
+		for _, c := range t.calls {
+			b.WriteString("\n" + a.styles.thought.Render("→ "+c))
+		}
+		if t.text == "" && t.thought == "" && a.generating && i == len(a.turns)-1 {
+			b.WriteString(a.styles.thought.Render(a.spin.View() + " …"))
 		}
 	}
-	return lipgloss.NewStyle().Width(a.view.Width).Render(b.String())
+	return b.String()
 }
 
 func (a app) transcriptTurnOffset(turnID string) int {