feat(runtime): delta session snapshots — Flash-Next snapshot costs one chunk at any depth (builds on #825)

[fivetide]

Summary

Builds on #825; until that merges, this PR also contains its commit. Review the delta commit 872b0a128 on its own.

Session snapshots become deltas. A snapshot stores the state that is overwritten in place whole, but of each append-only row stream only the rows above its parent: the deepest snapshot of the same prefix that existed when it was captured. A restore walks the chain from the root.

 trait SessionState
-  snapshot_parts → { meta, parts: Vec<StatePart> }
+  snapshot_parts → { meta, layout: StateLayout { fixed: Vec<StatePart>, rows: Vec<RowStream> } }
-  restore_parts  → Vec<StatePart>
+  restore_parts  → StateLayout      # destination, with the snapshot's row counts

at_boundary(p)
  parent = deepest snapshot of prefix[..b], b < p, published or pending
  store fixed parts whole + rows [parent.to, live.rows) per stream
  link(parent)  → pinned while it has children

begin(reused)
  chain = leaf → parent → … → root      (each get refreshes LRU)
  one copy_regions: leaf's fixed parts + every link's row segment at row offset `from`
  check: segments contiguous from 0, end at the destination's row counts

evict: pop_lru only sees unpinned entries → leaves only; dropping a leaf unlinks (maybe unpins) its parent
commit: parents before children; a refused parent drops its pending children

• Qwen4 code: the target and MTP-head codecs now just label their QSA K/V, raw and pooled arenas as RowStreams.
• Unchanged: the generate loop, MTP driver, daemon, loader and dispatch interpreter.
• Cost:

per 8192-token Flash-Next MTP snapshot	before	after
snapshot at depth k chunks	k × 481 + 32 MiB	513 MiB
one 64K session, all 8 boundaries	≈ 17 GiB	≈ 4 GiB
subagents sharing a system-prompt chunk	each pays	shared link

Which surface(s) does this touch?

• serve — runtime session_cache
• arch crate(s): hipfire-arch-qwen4 (codec layout only)

Evidence

Strix Halo gfx1151, HIP 7.2, qwen3.8-flash-next-gptq3.mq4 sha256 8b15b6fede7d7c5bfed0db4720a8295bedda51bc93e545fa242bd50d0f200972. QSA is F32 (the serve default here), GDN is Q8, the context backend is VMM.

• Bit-exact through chains and branches (session_cache_hw, extended). A = 3 chunks + 300 tokens; B = A's first chunk + 8,392 other tokens. Both are prefilled cold first, so B's 2-chunk snapshot is a delta over A's root. Then A is restored through its 3-link chain and B through the shared root:

  A cold ids [248045, 248045, 248045, 248045, 248046, 198, 248045, 74455, …]
  A warm ids [248045, 248045, 248045, 248045, 248046, 198, 248045, 74455, …]
  B cold ids [5513, 248046, 198, 248045, 74455, 198, 248068, 271, …]
  B warm ids [5513, 248046, 198, 248045, 74455, 198, 248068, 271, …]
  test restored_prefill_matches_cold_on_flash_next ... ok
  

  Final logits are byte-equal for both prompts. This also proves the invariant the design depends on: rows below a boundary never change after it.
• Unit test (GPU toy state). The state has a fixed part plus per-token rows that depend causally on the prefix. Checked: an exact restore through a 3-link chain and a branch; leaf-only eviction (the full budget evicts A's deepest leaf, A still restores at 2 chunks, the shared root stays pinned); pins released when an uncommitted turn is abandoned; snapshots over the budget are skipped.
• Serve, greedy, MTP:

  A 21550 tok  15.9 s  cached 0
  B  8142 tok   6.2 s  cached 0
  C 14154 tok   5.9 s  cached 8192    # C = first 2/3 of A's text + another question; output == cache-off C (11.1 s)
  A 21550 tok   4.9 s  cached 16384   # 2-link MTP chain; output == A#1
  

• Static checks: cargo build --release and clippy on the changed crates are clean; the hipfire-runtime session_cache and checkpoint_pool tests pass; layering and crate maps are clean.

Test plan

• cargo build --release clean
• session_cache_hw (ignored hardware test) and the runtime session_cache test pass on gfx1151
• serve greedy MTP A/B/C/A matches cache-off and cold outputs
• CI jobs green

Merge Danger

Door: two-way. Snapshots live only in process memory; a revert or memory.session_cache_bytes = 0 returns to the earlier behaviour.

Blast Radius: Flash-Next session cache.

• Corruption propagates: a corrupted parent now breaks every descendant. The guards are the exact-logits chain and branch test, and the layout checks on restore (contiguous segments, row sizes, final row counts).
• Pinned ancestors: they can hold budget while their leaves are hot. Eviction then skips the capture rather than oversubscribing.

[fivetide]

Review fixes pushed in 7b715e531:

#	Finding	Fix
1	HIPFIRE_SESSION_CACHE_MODEL missing from the env inventory (lifecycle gate failed)	Regenerated with check-lifecycle.py --write; the gate passes.
2	Failed free-VRAM query left the parent pinned by a phantom child and aborted the prefill	The query failure is now a capture skip (memory query failed) through the unlink path, with no eviction; the prefill continues.
3	Exactness checked only through final logits and 16 ids	session_cache_hw compares a SHA-256 of every state part (metadata, fixed parts, valid rows of every row stream), cold vs restored.
4	No exactness check for the MTP draft head	The test adds the native MTP route (target, draft head and its policy, seed token) over the same chain and branch.
5	B's link to A's root not asserted	The test asserts each route stores exactly four one-chunk snapshots.
6	No GPU-free test for pop_lru	Host test: it returns the oldest unpinned entry and never a pinned one.

gfx1151, qwen3.8-flash-next-gptq3.mq4 (8b15b6fe…), F32 QSA, Q8 GDN, VMM:

AR:  1998794752 bytes stored = 4 × 499698688 per one-chunk snapshot
AR A / AR B   all state parts equal, final logits byte-equal, 16 ids equal
MTP: 2154182656 bytes stored = 4 × 538545664
MTP A seed cold 248045 warm 248045, MTP B seed cold 5513 warm 5513, all state parts equal
test restored_prefill_matches_cold_on_flash_next ... ok

The runtime session_cache and checkpoint_pool tests pass (28). Lifecycle, env-docs, layering and crate-map checks pass, and cargo build --release is clean.