Function analyzePasses

packages/e2e-tests/src/cache-analysis.ts:181–246

(requests: MinimalRequest[])

 * `requests` should already be filtered to the main-agent requests in order.
 */
export function analyzePasses(requests: MinimalRequest[]): PassComparison[] {
    const out: PassComparison[] = [];
    const snaps = requests.map((r) => buildSegments(r.body));
    for (let k = 0; k < snaps.length; k += 1) {
        if (k === 0) {
            out.push({
                index: 0,
                verdict: "BASE",
                divergeIndex: -1,
                divergeSegmentId: null,
                cachedPrefixBytes: 0,
                cachedPrefixAt: "(base)",
                diff: null,
            });
            continue;
        }
        const prev = snaps[k - 1];
        const cur = snaps[k];
        const idx = firstDivergence(prev, cur);
        if (idx === -1) {
            out.push({
                index: k,
                verdict: "SAME",
                divergeIndex: -1,
                divergeSegmentId: null,
                cachedPrefixBytes: cachedPrefixBytes(cur, -1).bytes,
                cachedPrefixAt: cachedPrefixBytes(cur, -1).at,
                diff: null,
            });
            continue;
        }
        // The cache was WRITTEN during the previous request, at the previous
        // request's cache_control breakpoints. So the reusable cached prefix for
        // this transition is bounded by PREV's last breakpoint — not cur's.
        // OpenCode walks the breakpoint forward to the last 1-2 messages every
        // turn, so cur's last breakpoint sits AHEAD of freshly-appended tail
        // content; comparing against it would mis-flag benign tail growth as a
        // bust. The correct invariant: everything up to and including prev's
        // last breakpoint must stay byte-identical in cur.
        //   STABLE: first divergence is strictly AFTER prev's last breakpoint
        //           (only uncached tail changed, or pure append).
        //   BUST:   first divergence is at/before prev's last breakpoint
        //           (content that was cached got rewritten).
        // prevLastBreakpoint === -1 means prev cached nothing → no bust possible.
        const prevLastBreakpoint = lastBreakpointIndex(prev);
        const verdict: BustVerdict = idx > prevLastBreakpoint ? "STABLE" : "BUST";
        const cp = cachedPrefixBytes(cur, idx);
        const seg = cur[idx] ?? prev[idx];
        out.push({
            index: k,
            verdict,
            divergeIndex: idx,
            divergeSegmentId: seg?.id ?? `seg[${idx}]`,
            cachedPrefixBytes: cp.bytes,
            cachedPrefixAt: cp.at,
            diff:
                verdict === "BUST"
                    ? {