@@ -13,14 +13,12 @@ import (
 
 	"github.com/jack-work/largo"
 
-	"github.com/jack-work/figaro/internal/compose"
 	"github.com/jack-work/figaro/internal/config"
 	"github.com/jack-work/figaro/internal/livedoc"
 	"github.com/jack-work/figaro/internal/livelog/aria"
 	"github.com/jack-work/figaro/internal/message"
 	"github.com/jack-work/figaro/internal/store"
 	"github.com/jack-work/figaro/internal/term"
-	"github.com/jack-work/figaro/internal/turns"
 )
 
 // runShow handles `figaro show [--id <id>] [N] [-v|-l|-a]`.
@@ -38,6 +36,7 @@ type showOpts struct {
 	verbose  bool
 	literal  bool
 	details  bool // -o: the metadata Ctrl-O shows in the pager
+	maxBytes int  // --max-bytes: paint budget; the OLDEST turns are dropped first. 0 = none
 }
 
 // renderAria prints history for an aria. The default view derives the
@@ -46,65 +45,7 @@ type showOpts struct {
 // delta compression). N / --last N / --from A [--to B] / --all select a
 // unit range. --verbose and --literal use the raw IR path.
 func renderAria(loaded *config.Loaded, id string, args []string) {
-	opts := showOpts{last: 10, from: -1, to: -1, before: -1}
-
-	expanded := make([]string, 0, len(args))
-	for _, a := range args {
-		if len(a) > 2 && a[0] == '-' && a[1] != '-' { // expand bundled bool shorts (-vj)
-			for _, r := range a[1:] {
-				expanded = append(expanded, "-"+string(r))
-			}
-			continue
-		}
-		expanded = append(expanded, a)
-	}
-	needInt := func(i int) int {
-		if i+1 >= len(expanded) {
-			die("show: %s requires a value", expanded[i])
-		}
-		return mustAtoi(expanded[i+1])
-	}
-	for i := 0; i < len(expanded); i++ {
-		a := expanded[i]
-		switch {
-		case a == "-o" || a == "--details":
-			opts.details = true
-		case a == "-v" || a == "--verbose":
-			opts.verbose = true
-		case a == "-l" || a == "--literal":
-			opts.literal = true
-		case a == "-a" || a == "--all":
-			opts.all = true
-		case a == "-j" || a == "--json":
-			opts.jsonOut = true
-		case a == "--from":
-			opts.from = needInt(i)
-			i++
-		case a == "--to":
-			opts.to = needInt(i)
-			i++
-		case a == "--last":
-			opts.last = needInt(i)
-			i++
-		case strings.HasPrefix(a, "--from="):
-			opts.from = mustAtoi(strings.TrimPrefix(a, "--from="))
-		case strings.HasPrefix(a, "--to="):
-			opts.to = mustAtoi(strings.TrimPrefix(a, "--to="))
-		case strings.HasPrefix(a, "--last="):
-			opts.last = mustAtoi(strings.TrimPrefix(a, "--last="))
-		case a == "--before":
-			opts.before = needInt(i)
-			i++
-		case strings.HasPrefix(a, "--before="):
-			opts.before = mustAtoi(strings.TrimPrefix(a, "--before="))
-		default:
-			n, err := strconv.Atoi(a)
-			if err != nil {
-				die("usage: figaro show [--id <id>] [N | --last N | --from A [--to B] | -a] [-j|--json] [-o] [-v] [-l]")
-			}
-			opts.last = n
-		}
-	}
+	opts := parseShowArgs(args)
 
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
@@ -123,46 +64,63 @@ func renderAria(loaded *config.Loaded, id string, args []string) {
 		figaroID = r.FigaroID
 	}
 
-	// Read the IR through the angelus's shared LogCache.
+	// Read the IR through the angelus's shared LogCache, walking BACKWARD from
+	// the tail until the selector is covered (see show_window.go). One forward
+	// read from LT 0 is what this used to do, and the angelus caps a single
+	// read at 1000 entries, so a long aria was shown its own prefix and told
+	// that was all of it.
 	//
-	// SEAM (Phase 3): this reads the whole log and pages in memory, because
-	// every selector now speaks turn ids and turns are not derivable from an LT
-	// window: you cannot know which LT a turn starts at without walking. The
-	// paginated turn-aware read (Page/TurnPart, byte budget, bidirectional)
-	// replaces this wholesale; when it lands, `show` becomes a thin client of it
-	// and this block collapses to one call.
-	resp, err := acli.AriaRead(ctx, figaroID, 0, 0)
+	// SEAM (Phase 3): the walk still derives turns client-side, because turns
+	// are not derivable from an LT window without composing one. The paginated
+	// turn-aware read (Page/TurnPart, byte budget, bidirectional) replaces the
+	// walk wholesale; when it lands, `show` becomes a thin client of it.
+	w, err := gatherShowWindow(ctx, acli, figaroID, opts)
 	if err != nil {
 		die("aria.read: %s", err)
 	}
-	if len(resp.Entries) == 0 && resp.Total == 0 {
+	// A pre-turn-id aria can only be numbered from its head: see derivedIDs.
+	if !w.atHead && derivedIDs(w.entries) {
+		resp, rerr := acli.AriaRead(ctx, figaroID, 0, 0)
+		if rerr != nil {
+			die("aria.read: %s", rerr)
+		}
+		entries := make([]store.Entry[message.Message], len(resp.Entries))
+		for i, e := range resp.Entries {
+			entries[i].LT = e.LT
+			if uerr := json.Unmarshal(e.Payload, &entries[i].Payload); uerr != nil {
+				die("aria.read: parse LT=%d: %s", e.LT, uerr)
+			}
+		}
+		w = showWindow{entries: entries, total: resp.Total, atHead: len(entries) >= resp.Total, pages: 1, fromHead: true}
+		if !w.atHead {
+			showNote("this aria stores no turn ids (written before they existed), so its turns can only be counted from the head: showing the first %d of %d entries", len(w.entries), w.total)
+		}
+	}
+	if len(w.entries) == 0 && w.total == 0 {
 		fmt.Fprintln(os.Stderr, "(empty aria)")
 		return
 	}
-	entries := make([]store.Entry[message.Message], len(resp.Entries))
-	for i, e := range resp.Entries {
-		entries[i].LT = e.LT
-		if err := json.Unmarshal(e.Payload, &entries[i].Payload); err != nil {
-			die("aria.read: parse LT=%d: %s", e.LT, err)
-		}
-	}
+	entries := w.entries
 
 	// --verbose / --literal: the raw IR path (inline transitions + extras,
 	// or unrendered IR markdown).
 	if opts.verbose || opts.literal {
-		renderAriaIR(loaded, figaroID, entries, opts)
+		renderAriaIR(loaded, figaroID, w, opts)
 		return
 	}
 
-	// Default + --json: conversational units derived from the IR.
-	msgs := make([]message.Message, len(entries))
-	for i, e := range entries {
-		msgs[i] = e.Payload
-		msgs[i].LogicalTime = e.LT
-	}
-	turns.StampIDs(msgs)
-	turns := compose.Turns(msgs)
+	// Default + --json: conversational units derived from the IR. A window
+	// that does not start at the head drops its oldest turn: the page boundary
+	// fell inside it, and a turn without its prompt renders as an answer to
+	// nothing.
+	turns := trimPartialHead(composeTurns(entries), w.atHead)
 	lo, hi := selectTurnRange(turns, opts)
+	if lo < hi && opts.maxBytes > 0 {
+		if _, dropped := clipToBudget(turns[lo:hi], opts.maxBytes); dropped > 0 {
+			showNote("--max-bytes %d dropped the %d oldest turn(s) of this selection; a budget clips the head, never the tail", opts.maxBytes, dropped)
+			lo += dropped
+		}
+	}
 
 	if opts.jsonOut {
 		// The UI IR wire shape VERBATIM, an aria.Page, exactly what figaro.read
@@ -174,7 +132,9 @@ func renderAria(loaded *config.Loaded, id string, args []string) {
 			// Whole turns: `show` selects by turn, so no part is ever clipped.
 			page.Parts = append(page.Parts, aria.TurnPart{Turn: t, From: 0})
 		}
-		page.More = aria.More{Before: lo > 0, After: hi < len(turns)}
+		// Before is true when anything older exists, whether it was sliced
+		// off here or simply never walked to.
+		page.More = aria.More{Before: lo > 0 || !w.atHead, After: hi < len(turns)}
 		enc := json.NewEncoder(os.Stdout)
 		enc.SetIndent("", "  ")
 		if err := enc.Encode(page); err != nil {
@@ -188,10 +148,27 @@ func renderAria(loaded *config.Loaded, id string, args []string) {
 	// while ids are gapless and 1-based; printing lo+1 here would be a fourth
 	// coordinate system in the one command that just collapsed three.
 	if lo >= hi {
-		fmt.Printf("# aria %s: %d turns (no turn in range)\n\n", figaroID, len(turns))
+		if w.atHead {
+			fmt.Printf("# aria %s: %d turns (no turn in range)\n\n", figaroID, len(turns))
+		} else if w.fromHead {
+			fmt.Printf("# aria %s: no turn in that range within the first %d turns\n\n", figaroID, len(turns))
+		} else {
+			// The count is NOT known here: the walk stopped as soon as the
+			// selector was covered, so len(turns) is the size of the window,
+			// not of the aria. Printing it as a total restates the old bug.
+			fmt.Printf("# aria %s: no turn in that range within the %d turns walked back from the tail\n\n", figaroID, len(turns))
+		}
 		return
 	}
-	fmt.Printf("# aria %s: %d turns (showing %d–%d) · [N] is the turn to fork/send at\n\n", figaroID, len(turns), turns[lo].ID, turns[hi-1].ID)
+	if w.atHead {
+		fmt.Printf("# aria %s: %d turns (showing %d..%d) · [N] is the turn to fork/send at\n\n", figaroID, len(turns), turns[lo].ID, turns[hi-1].ID)
+	} else if w.fromHead {
+		// The legacy path: a forward read that stopped at the angelus's cap.
+		// Say FIRST, because that is what it is.
+		fmt.Printf("# aria %s: turns %d..%d, the first %d of %d entries · [N] is the turn to fork/send at\n\n", figaroID, turns[lo].ID, turns[hi-1].ID, len(w.entries), w.total)
+	} else {
+		fmt.Printf("# aria %s: turns %d..%d, walked back from the tail of %d entries · [N] is the turn to fork/send at\n\n", figaroID, turns[lo].ID, turns[hi-1].ID, w.total)
+	}
 	for i := lo; i < hi; i++ {
 		u := turns[i]
 		fmt.Println(term.Dim(fmt.Sprintf("[%d]", u.ID)))
@@ -210,6 +187,80 @@ func renderAria(loaded *config.Loaded, id string, args []string) {
 	}
 }
 
+// parseShowArgs turns `show`'s reassembled argv into showOpts.
+//
+// It is a named function, not a loop inside renderAria, because the flag most
+// recently broken here was broken by NOT BEING PARSED: cmdkit consumed
+// --max-bytes, the reassembly in cli.go did not pass it on, and `show`
+// exited 0 having ignored it. A parser you cannot call is a parser you cannot
+// test, and the unit test for the clipper it feeds passed the entire time.
+func parseShowArgs(args []string) showOpts {
+	opts := showOpts{last: 10, from: -1, to: -1, before: -1}
+
+	expanded := make([]string, 0, len(args))
+	for _, a := range args {
+		if len(a) > 2 && a[0] == '-' && a[1] != '-' { // expand bundled bool shorts (-vj)
+			for _, r := range a[1:] {
+				expanded = append(expanded, "-"+string(r))
+			}
+			continue
+		}
+		expanded = append(expanded, a)
+	}
+	needInt := func(i int) int {
+		if i+1 >= len(expanded) {
+			die("show: %s requires a value", expanded[i])
+		}
+		return mustAtoi(expanded[i+1])
+	}
+	for i := 0; i < len(expanded); i++ {
+		a := expanded[i]
+		switch {
+		case a == "-o" || a == "--details":
+			opts.details = true
+		case a == "-v" || a == "--verbose":
+			opts.verbose = true
+		case a == "-l" || a == "--literal":
+			opts.literal = true
+		case a == "-a" || a == "--all":
+			opts.all = true
+		case a == "-j" || a == "--json":
+			opts.jsonOut = true
+		case a == "--from":
+			opts.from = needInt(i)
+			i++
+		case a == "--to":
+			opts.to = needInt(i)
+			i++
+		case a == "--max-bytes":
+			opts.maxBytes = needInt(i)
+			i++
+		case a == "--last":
+			opts.last = needInt(i)
+			i++
+		case strings.HasPrefix(a, "--from="):
+			opts.from = mustAtoi(strings.TrimPrefix(a, "--from="))
+		case strings.HasPrefix(a, "--to="):
+			opts.to = mustAtoi(strings.TrimPrefix(a, "--to="))
+		case strings.HasPrefix(a, "--last="):
+			opts.last = mustAtoi(strings.TrimPrefix(a, "--last="))
+		case a == "--before":
+			opts.before = needInt(i)
+			i++
+		case strings.HasPrefix(a, "--before="):
+			opts.before = mustAtoi(strings.TrimPrefix(a, "--before="))
+		default:
+			n, err := strconv.Atoi(a)
+			if err != nil {
+				die("usage: figaro show [--id <id>] [N | --last N | --from A [--to B] | -a] [-j|--json] [-o] [-v] [-l]")
+			}
+			opts.last = n
+		}
+	}
+
+	return opts
+}
+
 func mustAtoi(s string) int {
 	v, err := strconv.Atoi(s)
 	if err != nil {
@@ -280,7 +331,8 @@ func selectTurnRange(turns []aria.Turn, o showOpts) (int, int) {
 // renderAriaIR is the raw IR path for --verbose / --literal: it renders
 // each message (markdown via largo, or unrendered when --literal) and, in
 // verbose mode, appends credo / state transitions / form.
-func renderAriaIR(loaded *config.Loaded, figaroID string, entries []store.Entry[message.Message], opts showOpts) {
+func renderAriaIR(loaded *config.Loaded, figaroID string, win showWindow, opts showOpts) {
+	entries := win.entries
 	start := 0
 	if !opts.all && len(entries) > opts.last {
 		start = len(entries) - opts.last
@@ -297,7 +349,10 @@ func renderAriaIR(loaded *config.Loaded, figaroID string, entries []store.Entry[
 		flush = func() { sw.Flush() }
 	}
 
-	fmt.Fprintf(w, "# aria %s: showing %d of %d messages\n\n", figaroID, len(entries)-start, len(entries))
+	// The denominator is the ARIA's message count, not the window's. A tail
+	// window that reported its own size as the total is exactly how `show`
+	// used to claim a 4000 message aria had 1000 messages in it.
+	fmt.Fprintf(w, "# aria %s: showing %d of %d messages\n\n", figaroID, len(entries)-start, win.total)
 	for _, e := range entries[start:] {
 		renderMessage(w, e.Payload, e.LT, opts.verbose)
 	}
 
@@ -204,7 +204,7 @@ func buildRouter(progName string, loaded *config.Loaded) *cmdkit.Router {
 		Aliases: []string{"history"},
 		Group:   "Prompt",
 		Short:   "Render an aria's message history",
-		Usage:   "show [<id>] [-n N | --from A [--to B] | --before T | -a] [-j] [-o] [-v] [-l]",
+		Usage:   "show [<id>] [-n N | --from A [--to B] | --before T | -a] [--max-bytes N] [-j] [-o] [-v] [-l]",
 		Long: `Render an aria's history as turns. A turn is one exchange: your
 question and every node the agent produced about it. The optional
 positional is the target aria id; default is the pid-bound aria.
@@ -223,6 +223,17 @@ Turns are labeled by their turn id: the coordinate send/fork
   figaro show -o                   with each block's address and timestamp
   figaro show eac16fef -v          verbose IR, labeled by LT
   figaro show -l                   raw IR, no rendering
+  figaro show --max-bytes 200000   cap what is painted; the OLDEST turns go first
+
+show reads from the TAIL backwards, one page at a time, and stops as soon as
+your selection is covered. Length is not a limit: the last N turns of a 40,000
+turn aria cost the same read as the last N of a short one, so redirecting show
+to a file captures the tail of any aria. Diagnostics go to stderr, so the file
+holds the conversation and nothing else.
+
+--max-bytes is the one cap, and it is opt-in. When the selection is larger
+than the budget, the OLDEST turns of it are dropped, never the newest, and a
+line on stderr says how many.
 
 LT is the model's coordinate: it counts the steps the model experienced,
 and most LTs sit mid-tool. It stays visible under -v/-l for debugging the
@@ -238,6 +249,7 @@ fig IR, but it is not an address: turns are.`,
 			{Long: "from", Description: "Start turn id (inclusive)"},
 			{Long: "to", Description: "End turn id (inclusive)"},
 			{Long: "before", Description: "Show N turns before this turn id (paginate backwards)"},
+			{Long: "max-bytes", Description: "Cap the painted size; the oldest turns of the selection are dropped first"},
 			{Long: "last", Short: "n", Description: "Show the last N turns (paginate backwards from the end)"},
 		},
 		Run: func(ctx *cmdkit.RunContext) error {
@@ -276,6 +288,13 @@ fig IR, but it is not an address: turns are.`,
 			if v := ctx.Flag("last"); v != "" {
 				args = append(args, "--last", v)
 			}
+			// A flag declared in the registry and not reassembled here is
+			// SILENTLY IGNORED: cmdkit consumes it, renderAria never sees it,
+			// and the command succeeds having done nothing you asked. That is
+			// how --max-bytes did nothing on its first run.
+			if v := ctx.Flag("max-bytes"); v != "" {
+				args = append(args, "--max-bytes", v)
+			}
 			runShow(ld, ariaID, args)
 			return nil
 		},