Read agent trajectories: records inside a document, a record that opens into itself, motion that can read it

[viict]

--lens could read a file of lines. An ATIF agent trajectory is one JSON
document whose records are the elements of its steps array, and each step is
a whole turn: a message, a thought, several tool calls and their results at
once. Reading one meant the generic tree, where half of what you see is
machine output.

tread --lens atif trajectory.json

▾ assistant  10:55   Reading the failing test first. The suite names a
                     fixture that no longer exists, so that is where it
                     starts.
                     thinking
                       The failing case reads a fixture the test tree no
                       longer ships, so the panic is a missing file.
                     ▾ bash    cargo test -q parse            → 32 lines
                         command   cargo test -q parse
                         timeout   120000
                         running 3 tests
                         test parse::empty ... FAILED
                         ⋯ +29 lines

The commits

• 2d133e2 record: lift the lens seam above any one record format.
  Grouping, row arithmetic, folding, search and painting stop belonging to
  .jsonl and sit behind a trait. Byte-identical output.
• 08adbd5 lens: read an agent trajectory whose records live inside a
  document. A lens says where its records are; the array is a second store
  over the existing lazy index, so a step is parsed when it is painted. The
  document's other top-level keys become the session record rather than being
  dropped.
• 4f21dd0 lens: put what was said under the row that says who said it.
  The summary row is the message's own first line and the rest follows under
  it, clipped with a truthful remainder.
• 38284ef pager: move by block where a document reads in blocks.
• abe52fb record: let a block boundary descend into a run that is open.
• f244400 lens: open a record into what it did, not into its JSON.
  A record opens into itself first: what was said in full, what it was
  thinking, and its tool calls as calls. A call is a row and opens too, into
  its arguments and what it returned. zt still goes straight to the tree.
  A seam change, not an ATIF one -- the agent dialect answers as well, so a
  Claude Code session opens the same way.
• 6c1e757 pager: move the cursor by row and put the jump on Tab.
  Reading real trajectories showed the block cursor was wrong: one j over an
  opened record leapt thirty rows of it. A closed block is exactly one row, so
  block motion differs from row motion only where it skips what the reader
  just opened. j/k move a row; Tab/S-Tab are the jump.

The last two commits are what the first attempt at this got wrong, found by
reading real trajectories rather than by any test.

Verification

• 1482 unit + 90 integration tests passing, from 1308 + 90 on master.
• clippy --all-targets -D warnings clean; all five cross-targets check;
  musl static build; tools/soak_pty.py clean.
• Opening does not track file size: 1.7 ms on an 86 MB synthetic trajectory
  against 1.8 ms on 55 KB.
• Rendered text is identical at width 92 and 1100 (126 709 non-space
  characters), the check that caught text painted nowhere on a wide terminal.
• Every painted row is reachable with j alone from the row above it, pinned
  mechanically rather than by inspection.

Known, and not fixed here

• tools/soak_json.sh and tools/soak_csv.sh each report one failure. Both
  predate this branch -- verified by building master -- and are the scripts
  asserting that a directory is an error, which the directory reader made
  false.
• A record in the array index costs about twice what a line costs in the line
  index (~630 B against ~315 B).
• A message row does not show its · 2 tool calls clause: that column is the
  message itself, and the calls are now rows under it. --toc still prints
  the clause.
• Crossing a clipped message is seven j presses. Tab clears it in one.