loop: every request is built from the log — boundary snapshot, header events, config-only waterfall

The loop is now transmission-stateless; a request is a pure function of
(session log, this step's rendered assembly, current AgentOptions):

- The reconstruction boundary is step/start: the messages snapshot is
  taken in the same synchronous frame immediately before the step/start
  append, so the request's messages are exactly the derivation over
  events[0..stepStartSeq) — an inject() from an agent/request listener
  (or any concurrent task) lands after the boundary and joins the NEXT
  request. This changes behavior for a synchronous step/start
  session/event listener that appends content (master derived after the
  append, so such a listener could reach the current request):
  agent/pre-step is the sanctioned seam for current-request content.
- agent/request is re-typed to config-only: (agent, turn, step,
  config: LlmCallConfig, next) → LlmCallConfig. The frozen seed comes
  from AgentOptions on a loop instance's first request (explicit options
  beat the logged baseline — fork overrides and resume reconfiguration
  stay correct) and from the log's folded header afterwards; listeners
  return a replacement to switch. Content shaping through the request is
  no longer expressible — model-visible content flows through the log
  channels.
- recordRequestHeader appends whatever header event the request owes the
  log before dispatch: an 'initial'/'resume' snapshot anchoring each
  loop instance, a round-trip-verified delta on change, a 'fallback'
  snapshot when the encoding cannot express it. Session.requestHeader()
  is the log's incrementally-folded baseline.
- Requests are deep-frozen before dispatch (deepFreeze exempts the
  AbortSignal — freezing one breaks AbortController.abort() outright);
  frozen + sessionId is the loop-built marker the dev invariant keys on.

Ported from #162 and re-anchored on the log: the append-extension /
frozen-end-to-end / compaction-resend / prompt-change property tests,
plus new specs for the boundary semantics, resume anchoring, and the
end-to-end theorem (every recorded request rebuilds byte-equal from the
log alone). Live cache-hit e2e (request-cache.e2e.ts) verified against
the real DeepSeek API. Snapshot goldens intentionally stale until the
single re-record after the compact/summary envelope lands.

packages/core/session/src/request-header.ts

@@ -104,6 +104,23 @@ function applyTools(prev: readonly ToolSchema[], delta: ToolsDelta): ToolSchema[
   return [...kept, ...delta.added]
 }
 
+/**
+ * Field-wise equality over canonical headers — the cheap comparison the
+ * writer's round-trip guard runs (`applyHeaderDelta(prev, delta)` must equal
+ * the intended header) and the loop runs to skip logging an unchanged header.
+ * Tools compare per-schema IN ORDER (canonical JSON), so a pure reordering is
+ * correctly unequal.
+ * @param a - one canonical header.
+ * @param b - the other.
+ * @returns whether config, system, and tools (in order) all match.
+ */
+export function headerEquals(a: EpochHeader, b: EpochHeader): boolean {
+  if (!callConfigEquals(a.config, b.config) || a.system !== b.system) return false
+  const at = a.tools ?? []
+  const bt = b.tools ?? []
+  return at.length === bt.length && at.every((tool, i) => sameSchema(tool, bt[i] as ToolSchema))
+}
+
 /**
  * Compute the `request/header-delta` payload between two canonical headers,
  * or undefined when they are equal. The caller MUST round-trip the result
@@ -154,10 +171,12 @@ export function applyHeaderDelta(
  * the dev invariant both use it; the live session tracks the same fold
  * incrementally.
  * @param events - session events in log order (non-header events are skipped).
+ * @param from - a previously folded state to continue from (the live session's
+ *   incremental cursor); omit to fold from nothing.
  * @returns the folded header, or undefined when no header event exists yet.
  */
-export function foldRequestHeader(events: readonly SessionEvent[]): EpochHeader | undefined {
-  let state: EpochHeader | undefined
+export function foldRequestHeader(events: readonly SessionEvent[], from?: EpochHeader): EpochHeader | undefined {
+  let state: EpochHeader | undefined = from
   for (const event of events) {
     if (event.type === 'request/header') {
       state = canonicalHeader(event.data.header)