@xamukavila/pxpipe 0.8.0

package/dist/dashboard.js

@@ -0,0 +1,1140 @@
+/**
+ * Live dashboard for the Node host. Serves the main HTML page and JSON
+ * polling endpoints. All "/api/*.json" endpoints recompute from disk on
+ * every request — pxpipe doesn't have a query layer, but a 1.5 MB JSONL
+ * streams in well under 100 ms.
+ *
+ * Legacy live-poll endpoints (left in place, the existing tick() loop uses
+ * them):
+ *
+ *   GET  /, /dashboard               → main HTML page
+ *   GET  /proxy-stats                → JSON aggregate over the in-mem ring
+ *   GET  /proxy-recent               → JSON ring buffer of recent requests
+ *   GET  /proxy-latest-png[?crop=N]  → raw PNG of the latest rendered image
+ *
+ * Session endpoints (read-only telemetry — no destructive operations):
+ *
+ *   GET  /api/sessions.json          → grouped sessions (sha8 + project + counts)
+ *   GET  /api/stats.json             → full-history aggregate (formerly `pxpipe stats`)
+ *
+ * Metric formulas and HTML shell originally ported from the Python reference
+ * implementation (deleted after live cache-rate validation hit 98.7% by tokens).
+ *
+ * Node-only by design. Workers host has no dashboard; use Workers Logs.
+ *
+ * Memory bound: ring buffer cap 50 events + a parallel ring of the last 50
+ * rendered PNGs (images are never persisted to disk, so this ring is the
+ * only place to view them). At a typical 75 KB PNG that's ~3-4 MB resident;
+ * a process restart starts the image ring empty.
+ */
+import * as fs from 'node:fs';
+import * as readline from 'node:readline';
+import { computeActualInputEff, computeBaselineInputEff, deriveBaselineWarmth, } from './core/baseline.js';
+import { computeOpenAIActualInputEff, computeOpenAIBaselineInputEff, computeOpenAIBaselineRawTokens, openAIOutputRate, } from './core/openai-savings.js';
+import { aggregateSessions, claudeCodeMap, filterSessions, } from './sessions.js';
+import { aggregateEventsFile, summaryToJson } from './stats.js';
+// Server-rendered UI (htmx + Alpine, vendored). No client bundle - the
+// fragments module renders finished HTML from the same payloads the JSON
+// endpoints serve.
+import { renderPage, renderToggleFragment, renderModelsFragment, renderContextMapFragment, renderSessionSummaryFragment, renderHeaderFragment, renderRecentFragment, renderLatestFragment, renderSessionsFragment, renderStatsTableFragment, } from './dashboard/fragments.js';
+import { getAllowedModelBases, getConfiguredModelBases, setAllowedModelBases, } from './core/applicability.js';
+const RECENT_CAP = 50;
+/** How many rendered PNGs to keep in the in-memory image ring. Matches
+ *  RECENT_CAP so every visible recent-requests row can still resolve its
+ *  image. Images are never written to disk — this ring is the only store. */
+const IMAGE_RING_CAP = 800;
+/*
+ * ─────────────────────────────────────────────────────────────────────────
+ *  PROVENANCE — every magic number below should trace to one of these:
+ *
+ *  [docs-pricing]   docs.anthropic.com/en/docs/about-claude/pricing
+ *                   Verified 2026-05-19 via WebFetch. The page lists per-model
+ *                   per-million-token rates and the cache-tier multipliers.
+ *
+ *  [count_tokens]   docs.anthropic.com/en/api/messages-count-tokens
+ *                   The dashboard's baseline number comes from a free side
+ *                   call to /v1/messages/count_tokens on the PRE-COMPRESSION
+ *                   body. No estimation, no α, no regression.
+ * ─────────────────────────────────────────────────────────────────────────
+ */
+/** Output-token rate multiplier (referenced to the input base rate).
+ *  Source: [docs-pricing] — Opus 4.7 lists $5/Mtok input and $25/Mtok
+ *  output (5×); Sonnet 4.7 lists $3/Mtok input and $15/Mtok output (5×).
+ *  Same ratio holds on Haiku 4.5 ($1/$5). */
+const OUTPUT_TOKEN_RATE = 5.0;
+/** Per-million-token input rate ASSUMED for the headline dollar figure.
+ *  Source: https://docs.claude.com/en/docs/about-claude/pricing — Opus 4.7
+ *  input is $5/Mtok (same as Opus 4.5 / 4.6; the previous "$2.50" value
+ *  here was a regression). Cache-write 5m = $6.25/Mtok (1.25×),
+ *  cache-read = $0.50/Mtok (0.10×).
+ *
+ *  This is exposed on /proxy-stats as `pricing_assumptions.input_per_mtok`
+ *  so the operator can see what we assumed and override if they're
+ *  running against a non-default deployment (Bedrock/Vertex add a 10%
+ *  premium; Sonnet would be $3/Mtok, etc.).
+ *
+ *  NOTE: Opus 4.7 uses a different tokenizer than 4.5/4.6 (per
+ *  docs.claude.com/en/docs/about-claude/pricing), so even at the same
+ *  $/Mtok rate, the same string maps to a different token count. The
+ *  honest oracle for "tokens in this body" is `count_tokens` against the
+ *  actual target model; do not trust hardcoded chars-per-token or
+ *  tokens-per-image constants on 4.7 without verifying against the
+ *  upstream probe. */
+// 2026-06-09: gate is Fable-5-only and Fable 5 bills $10/MTok input,
+// so the dashboard dollar figure uses that rate. Output tokens are
+// excluded entirely (the proxy can't move them), so this still
+// understates the real bill - treat it as "input-side $ saved".
+export const ASSUMED_INPUT_USD_PER_MTOK = 10.0;
+/** Route per-event accounting by upstream. OpenAI paths use the GPT cost
+ *  model (vision-token imaging, automatic 0.1× prefix cache, no count_tokens
+ *  probe, 8× output); everything else uses the Anthropic cache-aware baseline.
+ *  Anthropic paths are `/v1/messages[/count_tokens]`; neither word appears. */
+function isOpenAIEvent(path) {
+    if (!path)
+        return false;
+    return path.includes('responses') || path.includes('chat/completions');
+}
+/** Cache-aware eff bundle for one GPT event. Shared by the live `update()`
+ *  and `replay()` paths so both read identical per-row numbers. Pure: takes
+ *  plain scalars (replay has no Usage/TransformInfo objects, only JSONL fields).
+ *
+ *  GPT differs from Anthropic on every axis: input_tokens already INCLUDES the
+ *  cached subset (`cachedTokens`), there is no cache-create premium, the cached
+ *  prefix reads at ~0.1×, and the baseline is the measured `baselineImagedTokens`
+ *  (o200k text-token cost of the imaged content) vs the vision-token `imageTokens`
+ *  pxpipe actually paid — not a count_tokens probe. No per-session warmth state:
+ *  OpenAI caching is automatic/prefix-based and the discount is already folded
+ *  into the cached-input rate. See src/core/openai-savings.ts. */
+function gptEff(args) {
+    const { model, inputTokens: inp, outputTokens: out, cachedTokens: cached } = args;
+    const { imageTokens, baselineImagedTokens, compressed } = args;
+    const haveUsage = inp > 0 || out > 0;
+    // The transform measured what the imaged content would have cost as o200k
+    // text; without it there is no counterfactual to credit.
+    const haveBaseline = baselineImagedTokens > 0;
+    const actualInputEff = haveUsage ? computeOpenAIActualInputEff(inp, cached, model) : 0;
+    const creditSaving = haveBaseline && haveUsage && compressed;
+    const baselineInputEff = creditSaving
+        ? computeOpenAIBaselineInputEff(inp, cached, imageTokens, baselineImagedTokens, model)
+        : actualInputEff;
+    const outputEquiv = haveUsage ? out * openAIOutputRate(model) : 0;
+    // Raw, rate-free token counts for the session's compression ratio and the
+    // Details panel: actual = what we sent; baseline = the text-only equivalent.
+    const rawActual = inp;
+    const rawBaseline = computeOpenAIBaselineRawTokens(inp, imageTokens, baselineImagedTokens);
+    return {
+        haveUsage,
+        haveBaseline,
+        creditSaving,
+        actualInputEff,
+        baselineInputEff,
+        outputEquiv,
+        rawActual,
+        rawBaseline,
+    };
+}
+export class DashboardState {
+    recent = [];
+    /** Per-session dollar-weighted totals, keyed by `info.firstUserSha8`. The
+     *  dashboard surfaces ONLY the most-recently-active session via the
+     *  `serveCurrentSessionJson` endpoint — older sessions linger in the Map
+     *  so a tab refresh during a brief lull still finds the previous session,
+     *  but get evicted at `SESSION_CAP` to bound memory in long-running hosts. */
+    sessions = new Map();
+    /** sha8 of the most-recently-active session id. null when no events have
+     *  ever carried a `firstUserSha8` (e.g. a cold start with only passthrough
+     *  hits that the upstream probe never tagged). */
+    currentSessionId = null;
+    /** Per-session prior prefix size for the cache-aware TEXT baseline. Warm/cold
+     *  comes only from the server-observed cache_read on the actual request; this
+     *  map is used only after cr>0 to split the text counterfactual into reused vs
+     *  grown prefix tokens. Reconstructed identically in replay() from persisted
+     *  timestamps, so live and restored numbers agree. Capped with sessions. */
+    baselineWarmth = new Map();
+    /** Max age for reusing a prior prefix size after cr>0 has proved warmth. */
+    static CACHE_TTL_SEC = 300;
+    /** Hard cap on `sessions` Map entries. Keeps memory bounded in
+     *  long-running deployments. 50 sessions × ~13 numeric fields each is
+     *  comfortably under a MB even with fat bucket/passthrough histograms. */
+    static SESSION_CAP = 50;
+    totals = {
+        requests: 0,
+        compressedRequests: 0,
+        actualInputWeighted: 0,
+        baselineInputWeighted: 0,
+        outputWeighted: 0,
+        allBaselineEquivalentWeighted: 0,
+        allActualInputWeighted: 0,
+        allOutputWeighted: 0,
+        allUsageRequests: 0,
+        compressedPaidRequests: 0,
+        compressedActualInputWeighted: 0,
+        compressedOutputWeighted: 0,
+        passthroughPaidRequests: 0,
+        passthroughActualInputWeighted: 0,
+        passthroughOutputWeighted: 0,
+        textCharsMeasured: 0,
+        thinkingCharsMeasured: 0,
+        toolUseCharsMeasured: 0,
+        redactedBlockCountMeasured: 0,
+        eventsWithMeasurement: 0,
+        startedAt: Date.now() / 1000,
+    };
+    /** Bounded ring of the most recently rendered images (last IMAGE_RING_CAP).
+     *  Each request that rendered an image pushes one entry; the matching
+     *  RecentRow carries `img_id` so the dashboard can pull any image still in
+     *  the ring via /proxy-latest-png?id=N. In-memory only — images are never
+     *  persisted, so a restart starts this empty. */
+    images = [];
+    /** Monotonic image id source. Never reset, never reused — an evicted id
+     *  stays dangling on its RecentRow rather than pointing at a new image. */
+    nextImageId = 1;
+    /** Runtime kill switch for compression. When false, the proxy forwards
+     *  /v1/messages unchanged to upstream — pure passthrough, no images,
+     *  no transforms. Controlled by the dashboard "passthrough" toggle so
+     *  the operator can toggle the proxy's transform instantly.
+     *
+     *  Defaults to TRUE since 2026-06-09: scope is Fable 5 only, which reads
+     *  renders at 100/100 (no Opus read tax) with the same image billing, and
+     *  the live proxy record measured ~68% real input-token savings on dense
+     *  traffic — the old off-default rationale ("cache-illusory savings")
+     *  cited the superseded dead verdict. Verbatim recall is still lossy;
+     *  the dashboard toggle remains the kill switch. See FINDINGS.md. */
+    compressionEnabled = true;
+    /** Recent requests' transform breakdowns, for the Context Map panel + its
+     *  history selector. In-memory ring, newest last. */
+    contextHistory = [];
+    setCompressionEnabled(on) {
+        this.compressionEnabled = on;
+    }
+    getCompressionEnabled() {
+        return this.compressionEnabled;
+    }
+    /** Resolved disk paths for the events.jsonl + 4xx-bodies sidecar dir. The
+     *  new sessions / cleanup endpoints need this; legacy callers that don't
+     *  pass `paths` opt out of those endpoints by returning 503. */
+    paths;
+    /** Test hook: when set, /api/sessions.json and /api/sessions/${id}.json
+     *  call this instead of `claudeCodeMap()` with the real `~/.claude/projects/`
+     *  path. Lets unit tests run in tens of ms instead of scanning hundreds of
+     *  the developer's actual Claude Code session files. */
+    ccMapFn;
+    constructor(paths, ccMapFn) {
+        this.paths = paths;
+        this.ccMapFn = ccMapFn ?? (() => claudeCodeMap());
+    }
+    /** Stash every rendered image into the ring (called from onRequest with the
+     *  raw ProxyEvent before info.firstImagePng is dropped by toTrackEvent).
+     *  Returns the assigned image ids in render order; empty array when there
+     *  are no images. The caller stamps ids[0] onto the RecentRow as `img_id`
+     *  for back-compat and the full list as `img_ids`. */
+    captureImage(info) {
+        const pngs = info.imagePngs ?? (info.firstImagePng ? [info.firstImagePng] : []);
+        if (pngs.length === 0)
+            return [];
+        const dims = info.imageDims ??
+            (info.firstImagePng
+                ? [{ width: info.firstImageWidth ?? 0, height: info.firstImageHeight ?? 0 }]
+                : []);
+        const ids = [];
+        for (let i = 0; i < pngs.length; i++) {
+            const id = this.nextImageId++;
+            const width = dims[i]?.width ?? 0;
+            const height = dims[i]?.height ?? 0;
+            const kb = (pngs[i].length / 1024).toFixed(1);
+            const meta = `${width}×${height} · ${kb} KB · image ${i + 1}/${pngs.length}`;
+            this.images.push({
+                id,
+                png: pngs[i],
+                meta,
+                width,
+                height,
+                ts: Date.now() / 1000,
+                sourceText: info.imageSourceText,
+            });
+            ids.push(id);
+        }
+        // Evict the oldest entries past the cap. splice() keeps insertion order
+        // so images[images.length - 1] is always the latest render.
+        if (this.images.length > IMAGE_RING_CAP) {
+            this.images.splice(0, this.images.length - IMAGE_RING_CAP);
+        }
+        return ids;
+    }
+    /** Fold one event into the running totals + ring buffer.
+     *
+     *  Savings math is gated on a per-request `baseline_tokens` measurement
+     *  from the parallel count_tokens probe AND an upstream usage block.
+     *  When either is missing, we still count the request but skip its
+     *  savings contribution — no estimation. */
+    update(ev) {
+        // Stash the image bytes before they get GC'd by the request finishing.
+        // The returned id (if any) is stamped onto this request's RecentRow so
+        // the dashboard can pull the exact image that request rendered.
+        const imgIds = ev.info ? this.captureImage(ev.info) : [];
+        const imgId = imgIds[0];
+        const u = ev.usage;
+        const info = ev.info;
+        const compressed = info?.compressed === true;
+        const inp = u?.input_tokens ?? 0;
+        const out = u?.output_tokens ?? 0;
+        const cc = u?.cache_creation_input_tokens ?? 0;
+        const cr = u?.cache_read_input_tokens ?? 0;
+        const gpt = isOpenAIEvent(ev.path);
+        // Unified per-row accounting, filled by the provider branch below. The
+        // downstream totals / per-session / recent-row code reads only these —
+        // it never re-derives cache math, so Anthropic and GPT can't drift.
+        let haveUsage;
+        let haveBaseline;
+        let creditSaving;
+        let actualInputEff;
+        let baselineInputEff;
+        let outputEquiv;
+        let rawActual; // raw tokens sent (session ratio + Details realInput)
+        let rawBaseline; // raw text-only counterfactual tokens
+        let baselineForRow; // baseline token count for contextHistory/recent
+        let cacheReadForRow; // tokens to surface in the "Cache hits" column
+        let warmForRow; // did the TEXT baseline read warm? Server-observed:
+        // Anthropic cr>0 or GPT cached_tokens>0. Drives Context Map narration.
+        if (gpt) {
+            // GPT cost model: no count_tokens probe, no cache-create premium, no
+            // per-session warmth — the discount is automatic and folded into the
+            // cached-input rate. Baseline is the measured imaged-vs-text delta.
+            const e = gptEff({
+                model: ev.model,
+                inputTokens: inp,
+                outputTokens: out,
+                cachedTokens: u?.cached_tokens ?? 0,
+                imageTokens: info?.imageTokens ?? 0,
+                baselineImagedTokens: info?.baselineImagedTokens ?? 0,
+                compressed,
+            });
+            haveUsage = e.haveUsage;
+            haveBaseline = e.haveBaseline;
+            creditSaving = e.creditSaving;
+            actualInputEff = e.actualInputEff;
+            baselineInputEff = e.baselineInputEff;
+            outputEquiv = e.outputEquiv;
+            rawActual = e.rawActual;
+            rawBaseline = e.rawBaseline;
+            baselineForRow = e.rawBaseline;
+            cacheReadForRow = u?.cached_tokens ?? 0;
+            // GPT's prefix discount is automatic: cached_tokens>0 ⇒ it read warm.
+            warmForRow = (u?.cached_tokens ?? 0) > 0;
+        }
+        else {
+            haveUsage = u !== undefined && (inp > 0 || out > 0 || cc > 0 || cr > 0);
+            const baseline = info?.baselineTokens;
+            // Honest gating: only attribute savings when BOTH baseline probes
+            // resolved (status === 'ok'). When the cacheable-prefix probe failed
+            // (status === 'partial') we previously fell through to cacheable=0,
+            // which silently charges the unproxied counterfactual the cold-input
+            // rate on tokens that actually would have been cache-discounted —
+            // fabricating "$ saved". Excluding the row is the only honest move
+            // until the probe succeeds.
+            const probeOk = info?.baselineProbeStatus === 'ok'
+                // Back-compat: hosts that haven't adopted baselineProbeStatus yet
+                // still see fields land; we accept legacy rows where the full-body
+                // probe resolved AND (either no markers existed OR cacheable did too).
+                || (info?.baselineProbeStatus === undefined && baseline !== undefined && baseline > 0);
+            haveBaseline = typeof baseline === 'number' && baseline > 0 && probeOk;
+            // Weighted INPUT cost we actually paid this turn.
+            actualInputEff = haveUsage ? computeActualInputEff(inp, cc, cr) : 0;
+            // pxpipe only reduces input by imaging the static slab. An UNCOMPRESSED
+            // row had its body forwarded untouched, so its unproxied counterfactual
+            // IS exactly what it paid — crediting the cache-modeled baseline there
+            // (which prices the prefix at the cache-READ rate) fabricates savings on
+            // passthrough traffic. Only credit the counterfactual when the row was
+            // actually compressed AND we have a usable probe.
+            creditSaving = haveBaseline && haveUsage && compressed;
+            // Cache-aware, server-observed baseline. INVARIANT: pxpipe is credited ONLY
+            // for the text it imaged away — NEVER for caching. The imagined text path
+            // gets the same observed cache state as the actual request: cr>0 means warm
+            // for both, cr===0 means cold for both. No wall-clock-only inference.
+            // Uncompressed rows fall back to actualInputEff → zero savings.
+            const cacheable = info?.baselineCacheableTokens ?? 0;
+            // If cr>0 proved warmth, a completed prior with the same prefix refines the
+            // reused/grown split for the text baseline. Use request start for that
+            // lookup; an overlapping request that had not completed could not provide a
+            // prior prefix size for this in-flight request.
+            const sidNow = info?.firstUserSha8;
+            const prefixShaNow = info?.systemSha8;
+            const completionSec = Date.now() / 1000;
+            const requestStartSec = completionSec - Math.max(0, ev.durationMs || 0) / 1000;
+            const warmthPrev = typeof sidNow === 'string' && sidNow.length > 0
+                ? this.baselineWarmth.get(sidNow)
+                : undefined;
+            // Warmth itself is cr-only; prior state only estimates the warm split.
+            // Centralised in deriveBaselineWarmth so update()/replay()/sessions can't drift.
+            const { warm, prevCacheable } = deriveBaselineWarmth(warmthPrev, requestStartSec, cacheable, cr, DashboardState.CACHE_TTL_SEC, prefixShaNow);
+            baselineInputEff = creditSaving
+                ? computeBaselineInputEff(baseline, cacheable, inp, cc, cr, warm, prevCacheable)
+                : actualInputEff;
+            // Record this completed turn's prefix size for future cr>0 split estimates.
+            // Carry the prior cacheable when this row has no probe.
+            if (typeof sidNow === 'string' && sidNow.length > 0 && haveUsage) {
+                this.baselineWarmth.set(sidNow, {
+                    ts: completionSec,
+                    cacheable: cacheable > 0 ? cacheable : (warmthPrev?.cacheable ?? 0),
+                    prefixSha: prefixShaNow ?? warmthPrev?.prefixSha,
+                });
+                if (this.baselineWarmth.size > DashboardState.SESSION_CAP) {
+                    const firstKey = this.baselineWarmth.keys().next().value;
+                    if (firstKey !== undefined)
+                        this.baselineWarmth.delete(firstKey);
+                }
+            }
+            // Output tokens are identical with/without compression — the proxy never
+            // touches the response body. They show up on BOTH sides of the savings
+            // ratio at their actual rate (OUTPUT_TOKEN_RATE × input rate) so the
+            // denominator reflects the full bill the user actually pays. Without
+            // this, an output-heavy turn would silently inflate the "saved %"
+            // headline relative to what Anthropic's weekly limit meters as token
+            // consumption (input + output × 5).
+            outputEquiv = haveUsage ? out * OUTPUT_TOKEN_RATE : 0;
+            rawActual = inp + cc + cr;
+            rawBaseline = baseline ?? 0;
+            baselineForRow = baseline ?? 0;
+            cacheReadForRow = cr;
+            warmForRow = warm; // server-observed cache read (cr>0)
+        }
+        // Record the request's transform breakdown for the Context Map panel. This
+        // runs AFTER the eff-tokens are computed so the Details headline reads the
+        // SAME cache-weighted pair as the recent row's As-text / Sent / Saved
+        // columns (baselineInputEff / actualInputEff) — the two panels can no longer
+        // disagree. Raw counts are kept for the cache-blind sub-line. Gate on
+        // haveUsage so an in-flight request doesn't render a bogus "-100%".
+        if (info && haveUsage && imgId !== undefined) {
+            // Key by the request's first image id so the recent table's "view" link
+            // (which carries that id) maps straight to this breakdown.
+            this.contextHistory.push({
+                id: imgId,
+                baselineTokens: baselineForRow,
+                realInput: rawActual,
+                baselineInputEff,
+                actualInputEff,
+                haveBaseline,
+                cacheRead: cacheReadForRow,
+                warm: warmForRow,
+                output: out,
+                imageCount: info.imageCount ?? 0,
+                buckets: { ...(info.bucketChars ?? {}) },
+                imageIds: [...imgIds],
+                compressed,
+            });
+            // Keep in lockstep with RECENT_CAP so every "view" link in the recent
+            // table resolves to a real breakdown (was 30 < 50, so older visible rows
+            // silently fell back to the latest request's data).
+            if (this.contextHistory.length > RECENT_CAP) {
+                this.contextHistory.splice(0, this.contextHistory.length - RECENT_CAP);
+            }
+        }
+        this.totals.requests += 1;
+        if (compressed)
+            this.totals.compressedRequests += 1;
+        // Measured headline: only compressed rows with a usable probe. An
+        // uncompressed row contributes zero saved (baseline === actual), so
+        // including it here would only dilute the "saved on rows we moved" %.
+        if (creditSaving) {
+            this.totals.baselineInputWeighted += baselineInputEff;
+            this.totals.actualInputWeighted += actualInputEff;
+            this.totals.outputWeighted += outputEquiv;
+        }
+        // All-rows COUNTERFACTUAL spend, ungated on the probe — the honest
+        // denominator for "did pxpipe move my real bill". Measured rows
+        // contribute their cache-aware baseline (what the unproxied path
+        // would have billed); unmeasured/probe-failed/passthrough rows
+        // contribute their actual input (pxpipe either didn't run or we
+        // can't measure the counterfactual, so actual ≈ baseline). This
+        // keeps the ratio bounded at 100% — you can't save more than you
+        // would have paid.
+        if (haveUsage) {
+            // baselineInputEff already folds the uncompressed/probe-failed fallback
+            // to actualInputEff, so passthrough rows contribute zero saved here.
+            this.totals.allBaselineEquivalentWeighted += baselineInputEff;
+            this.totals.allActualInputWeighted += actualInputEff;
+            this.totals.allOutputWeighted += outputEquiv;
+            this.totals.allUsageRequests += 1;
+            // Direct observed compressed-vs-passthrough split. No counterfactual,
+            // no probe gating — just partition the paid-rows set by which path
+            // actually ran this turn. Headline answers "is the compressed path
+            // cheaper per request on real traffic". Selection bias (the gate
+            // routes each turn) is real; sample counts go to the UI so the
+            // operator can judge sufficiency.
+            if (compressed) {
+                this.totals.compressedPaidRequests += 1;
+                this.totals.compressedActualInputWeighted += actualInputEff;
+                this.totals.compressedOutputWeighted += outputEquiv;
+            }
+            else {
+                this.totals.passthroughPaidRequests += 1;
+                this.totals.passthroughActualInputWeighted += actualInputEff;
+                this.totals.passthroughOutputWeighted += outputEquiv;
+            }
+        }
+        // Per-session aggregation. Uses the SAME baseline/actual/output math as
+        // the global accumulators above, partitioned by `info.firstUserSha8`
+        // so the dashboard's "current session" panel can show what's happening
+        // RIGHT NOW instead of stale lifetime numbers. Untagged events (no
+        // firstUserSha8 — cold start, passthrough probe failures) are skipped
+        // rather than bucketed into a synthetic "unknown" session.
+        const sid = info?.firstUserSha8;
+        if (typeof sid === 'string' && sid.length > 0) {
+            this.currentSessionId = sid;
+            let s = this.sessions.get(sid);
+            if (!s) {
+                s = {
+                    sessionId: sid,
+                    baselineInputWeighted: 0,
+                    actualInputWeighted: 0,
+                    baselineMeasuredCount: 0,
+                    allActualInputWeighted: 0,
+                    allOutputWeighted: 0,
+                    rawActualTokens: 0,
+                    rawBaselineTokens: 0,
+                    rawOutputTokens: 0,
+                };
+                this.sessions.set(sid, s);
+                // Cap memory — drop the first (oldest by insertion order) session
+                // when over budget. We no longer track lastSeen privately on the
+                // class — insertion order is a fine proxy because `currentSessionId`
+                // (set above on every update) is what the serve path uses to pick
+                // the most-recent session, not a scan of `this.sessions`.
+                if (this.sessions.size > DashboardState.SESSION_CAP) {
+                    const firstKey = this.sessions.keys().next().value;
+                    if (firstKey !== undefined)
+                        this.sessions.delete(firstKey);
+                }
+            }
+            // Reuse the same haveUsage / haveBaseline guards + the
+            // baselineInputEff / actualInputEff locals computed earlier in
+            // update() so the lifetime totals block (above) and the per-session
+            // block (here) read the same values. Re-deriving them here would
+            // duplicate the cache-aware-baseline math and invite drift.
+            if (creditSaving) {
+                s.baselineInputWeighted += baselineInputEff;
+                s.actualInputWeighted += actualInputEff;
+                s.baselineMeasuredCount += 1;
+                // RAW, rate-free compression: real tokens sent vs the same body as text.
+                s.rawActualTokens += rawActual;
+                s.rawBaselineTokens += rawBaseline;
+                s.rawOutputTokens += out; // not compressed; added to BOTH sides for the honest total
+            }
+            // ALL-rows session bill — mirrors the global `if (haveUsage)` block
+            // above (allActualInputWeighted / allOutputWeighted). Used as the
+            // honest denominator for the session's saved-% so caching wins on
+            // unmeasured requests still count toward "what you actually paid".
+            if (haveUsage) {
+                s.allActualInputWeighted += actualInputEff;
+                s.allOutputWeighted += outputEquiv;
+            }
+        }
+        // Measurement totals are independent of usage/baseline gating — they
+        // accumulate whenever the scanner produced numbers. The scanner sets
+        // measurement to undefined on 5xx (no body to scan) and on unknown
+        // content-types; we count an event as "measured" when it has any.
+        const m = ev.measurement;
+        if (m) {
+            this.totals.textCharsMeasured += m.textChars;
+            this.totals.thinkingCharsMeasured += m.thinkingChars;
+            this.totals.toolUseCharsMeasured += m.toolUseChars;
+            this.totals.redactedBlockCountMeasured += m.redactedBlockCount;
+            this.totals.eventsWithMeasurement += 1;
+        }
+        const row = {
+            ts: Date.now() / 1000,
+            method: ev.method,
+            path: ev.path,
+            model: ev.model,
+            status: ev.status,
+            compressed,
+            cc_added: compressed ? 1 : undefined,
+            input_tokens: haveUsage ? inp : undefined,
+            output_tokens: haveUsage ? out : undefined,
+            cache_create: haveUsage ? cc : undefined,
+            cache_read: haveUsage ? cacheReadForRow : undefined,
+            actual_input: haveUsage ? round1(actualInputEff) : undefined,
+            baseline_input: creditSaving ? round1(baselineInputEff) : undefined,
+            session_saved_so_far_delta: creditSaving ? round1(baselineInputEff - actualInputEff) : undefined,
+            img_id: imgId,
+            img_ids: imgIds,
+        };
+        this.recent.push(row);
+        if (this.recent.length > RECENT_CAP)
+            this.recent.splice(0, this.recent.length - RECENT_CAP);
+    }
+    /** On startup, fold the last N entries from the JSONL events file back
+     *  into the ring buffer so a process restart doesn't show an empty table.
+     *  Cumulative totals are *not* restored (the file may have rotated, and
+     *  double-counting is worse than starting fresh). */
+    async replay(filePath) {
+        try {
+            await fs.promises.access(filePath, fs.constants.R_OK);
+        }
+        catch {
+            return; // no file yet, nothing to replay
+        }
+        const stream = fs.createReadStream(filePath, { encoding: 'utf8' });
+        const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+        const tail = [];
+        for await (const line of rl) {
+            if (!line)
+                continue;
+            try {
+                const ev = JSON.parse(line);
+                tail.push(ev);
+                if (tail.length > RECENT_CAP)
+                    tail.shift();
+            }
+            catch {
+                /* skip malformed line */
+            }
+        }
+        // Replay mirrors the live update() warmth logic (per-session baselineWarmth,
+        // cr-grounded) so it produces byte-identical per-row numbers to update().
+        for (const t of tail) {
+            const inp = t.input_tokens ?? 0;
+            const out = t.output_tokens ?? 0;
+            const cc = t.cache_create_tokens ?? 0;
+            const cr = t.cache_read_tokens ?? 0;
+            const compressed = t.compressed === true;
+            const gpt = isOpenAIEvent(t.path);
+            // Same unified accounting as update(); see the branch comments there.
+            let haveUsage;
+            let haveBaseline;
+            let creditSaving;
+            let actualInputEff;
+            let baselineInputEff;
+            let rawActual;
+            let rawBaseline;
+            let baselineForRow;
+            let cacheReadForRow;
+            let warmForRow; // text-baseline warmth for the Context Map narration
+            if (gpt) {
+                const e = gptEff({
+                    model: t.model,
+                    inputTokens: inp,
+                    outputTokens: out,
+                    cachedTokens: t.cached_tokens ?? 0,
+                    imageTokens: t.image_tokens ?? 0,
+                    baselineImagedTokens: t.baseline_imaged_tokens ?? 0,
+                    compressed,
+                });
+                haveUsage = e.haveUsage;
+                haveBaseline = e.haveBaseline;
+                creditSaving = e.creditSaving;
+                actualInputEff = e.actualInputEff;
+                baselineInputEff = e.baselineInputEff;
+                rawActual = e.rawActual;
+                rawBaseline = e.rawBaseline;
+                baselineForRow = e.rawBaseline;
+                cacheReadForRow = t.cached_tokens ?? 0;
+                warmForRow = (t.cached_tokens ?? 0) > 0;
+            }
+            else {
+                haveUsage = inp > 0 || out > 0 || cc > 0 || cr > 0;
+                const baseline = t.baseline_tokens;
+                const cacheable = t
+                    .baseline_cacheable_tokens ?? 0;
+                const probeStatus = t.baseline_probe_status;
+                // Same gating rule as update(): require an explicit 'ok' status when
+                // present; fall back to "have a baseline number" for legacy JSONL.
+                const probeOk = probeStatus === 'ok'
+                    || (probeStatus === undefined && typeof baseline === 'number' && baseline > 0);
+                haveBaseline = typeof baseline === 'number' && baseline > 0 && probeOk;
+                actualInputEff = haveUsage ? computeActualInputEff(inp, cc, cr) : 0;
+                // Mirror update(): only credit the cache-modeled counterfactual on
+                // compressed rows. Uncompressed/passthrough rows fall back to the
+                // actual cost so they show zero saved (no fabricated savings).
+                creditSaving = haveBaseline && haveUsage && compressed;
+                // Warm/cold is reconstructed from server-observed cr only. Persisted
+                // completion ts + duration_ms are used only to find a prior prefix size
+                // for the reused/grown split after cr>0 has proved warmth.
+                const sidR = t.first_user_sha8;
+                const prefixShaR = t.system_sha8;
+                const completionSecR = Date.parse(t.ts) / 1000;
+                const requestStartSecR = completionSecR - Math.max(0, t.duration_ms || 0) / 1000;
+                const warmthPrevR = typeof sidR === 'string' && sidR.length > 0 ? this.baselineWarmth.get(sidR) : undefined;
+                // Same cr-only warmth as update(); prior state only refines the split.
+                const { warm: warmR, prevCacheable: prevCacheableR } = deriveBaselineWarmth(warmthPrevR, requestStartSecR, cacheable, cr, DashboardState.CACHE_TTL_SEC, prefixShaR);
+                baselineInputEff = creditSaving
+                    ? computeBaselineInputEff(baseline, cacheable, inp, cc, cr, warmR, prevCacheableR)
+                    : actualInputEff;
+                if (typeof sidR === 'string' && sidR.length > 0 && haveUsage) {
+                    this.baselineWarmth.set(sidR, {
+                        ts: completionSecR,
+                        cacheable: cacheable > 0 ? cacheable : (warmthPrevR?.cacheable ?? 0),
+                        prefixSha: prefixShaR ?? warmthPrevR?.prefixSha,
+                    });
+                    if (this.baselineWarmth.size > DashboardState.SESSION_CAP) {
+                        const firstKey = this.baselineWarmth.keys().next().value;
+                        if (firstKey !== undefined)
+                            this.baselineWarmth.delete(firstKey);
+                    }
+                }
+                rawActual = inp + cc + cr;
+                rawBaseline = baseline ?? 0;
+                baselineForRow = baseline ?? 0;
+                cacheReadForRow = cr;
+                warmForRow = warmR; // server-observed cache read
+            }
+            // Rebuild the Context Map breakdown so old rows keep their "Saved" value
+            // and "Details" link after a restart. The PNG ring is in-memory and gone,
+            // so thumbnails can't return (imageIds: [], flagged `restored`) — but the
+            // headline %, buckets and Saved delta all reconstruct from the persisted
+            // event with the same cache-weighted math as the live update() path.
+            const imageCount = t.image_count ?? 0;
+            let imgId;
+            if (compressed && haveUsage && (imageCount > 0 || rawBaseline > 0)) {
+                imgId = this.nextImageId++;
+                this.contextHistory.push({
+                    id: imgId,
+                    baselineTokens: baselineForRow,
+                    realInput: rawActual,
+                    baselineInputEff,
+                    actualInputEff,
+                    haveBaseline,
+                    cacheRead: cacheReadForRow,
+                    warm: warmForRow,
+                    output: out,
+                    imageCount,
+                    buckets: { ...(t.bucket_chars ?? {}) },
+                    imageIds: [], // PNG ring is in-memory; not restorable across restart
+                    compressed,
+                    restored: true,
+                });
+                if (this.contextHistory.length > RECENT_CAP) {
+                    this.contextHistory.splice(0, this.contextHistory.length - RECENT_CAP);
+                }
+            }
+            const row = {
+                ts: Date.parse(t.ts) / 1000,
+                method: t.method,
+                path: t.path,
+                model: t.model,
+                status: t.status,
+                compressed,
+                cc_added: compressed ? 1 : undefined,
+                input_tokens: t.input_tokens,
+                output_tokens: t.output_tokens,
+                cache_create: t.cache_create_tokens,
+                cache_read: gpt ? cacheReadForRow : t.cache_read_tokens,
+                actual_input: haveUsage ? round1(actualInputEff) : undefined,
+                baseline_input: creditSaving ? round1(baselineInputEff) : undefined,
+                session_saved_so_far_delta: creditSaving ? round1(baselineInputEff - actualInputEff) : undefined,
+                img_id: imgId,
+                img_ids: imgId !== undefined ? [imgId] : undefined,
+            };
+            this.recent.push(row);
+        }
+    }
+    // ---- HTTP handlers ------------------------------------------------------
+    /**
+     * Per-session "what's happening right now" payload backing the
+     * `SessionSummary` panel. Scopes the dollar-weighted savings ratio + the
+     * per-bucket char attribution + the passthrough-reason histogram to the
+     * most-recently-active session (tracked via `info.firstUserSha8`) so the
+     * top-of-dashboard headline reflects the live session rather than stale
+     * lifetime aggregates from a previous run.
+     *
+     * Returns `{ sessionId: null, message: 'no active session yet' }` when no
+     * events have been received yet (or the first events were all untagged —
+     * cold start, probe failures) — `update()` only sets `currentSessionId`
+     * when a `firstUserSha8`-tagged event lands. The client renders a stale
+     * panel rather than zeroes when a session goes idle (NO `lastSeen >
+     * threshold` check here; see comment in `update()` for the rationale).
+     */
+    serveCurrentSessionJson() {
+        if (!this.currentSessionId) {
+            return jsonResponse({
+                sessionId: null,
+                message: 'no active session yet',
+            });
+        }
+        const s = this.sessions.get(this.currentSessionId);
+        if (!s) {
+            return jsonResponse({ sessionId: null, message: 'no active session yet' });
+        }
+        // Headline payload: the same dollar-weighted baseline/actual input
+        // accumulators the global Totals block exposes, plus the honest
+        // denominator (`baselineMeasuredCount` — only requests that carried a
+        // baseline measurement). We ALSO ship the ALL-rows session bill
+        // (`allActualInputWeighted` + `allOutputWeighted`) so the Svelte panel
+        // can compute saved-% against the full session bill instead of just
+        // the measured slice — matching the global `saved_pct_of_all_spend`
+        // math but scoped to one session. The Svelte panel does the dollar
+        // conversion itself so we don't round-trip pricing through the wire.
+        return jsonResponse({
+            sessionId: s.sessionId,
+            baselineInputWeighted: s.baselineInputWeighted,
+            actualInputWeighted: s.actualInputWeighted,
+            baselineMeasuredCount: s.baselineMeasuredCount,
+            allActualInputWeighted: s.allActualInputWeighted,
+            allOutputWeighted: s.allOutputWeighted,
+            rawActualTokens: s.rawActualTokens,
+            rawBaselineTokens: s.rawBaselineTokens,
+            rawOutputTokens: s.rawOutputTokens,
+        });
+    }
+    serveStats() {
+        // Two headline numbers, derived from the same per-event accumulators:
+        //
+        //   saved_pct_input_only = Σ saved / Σ baseline_input_eff × 100
+        //     What the proxy actually saved on the slice it can move (input).
+        //     Numerator = input tokens we didn't pay for (cache-aware).
+        //     Denominator = input tokens we WOULD have paid (cache-aware).
+        //     Output is excluded because the proxy doesn't touch it.
+        //
+        //   saved_pct_of_total_bill = Σ saved / Σ (baseline_input + output × 5) × 100
+        //     What share of the TOTAL bill the proxy saved. Honest counter to the
+        //     input-only number: on output-heavy sessions (long thinking blocks,
+        //     big edits) the percentage shrinks because output dominates.
+        //
+        //   token_equivalent_total = Σ (actual_input + output × 5)
+        //     What Anthropic's weekly limit actually meters — input × 1.0 +
+        //     output × 5.0 (the same ratio as the per-MTok price card). This is
+        //     the number that moves your "%% used this week" indicator.
+        const baseline = this.totals.baselineInputWeighted;
+        const actual = this.totals.actualInputWeighted;
+        const output = this.totals.outputWeighted; // already × OUTPUT_TOKEN_RATE
+        const saved = baseline - actual;
+        const pctInput = baseline > 0 ? (saved / baseline) * 100 : 0;
+        const baselineTotal = baseline + output;
+        const actualTotal = actual + output;
+        const pctTotal = baselineTotal > 0 ? (saved / baselineTotal) * 100 : 0;
+        // Share-of-all-spend: honest denominator. The numerator can only credit
+        // savings against rows where we have a probe baseline (otherwise it's
+        // estimation), but the denominator MUST include every request the user
+        // actually paid for — including passthrough rows, probe-failed rows,
+        // and untransformed turns the gate said no to. Otherwise the headline
+        // answers "did pxpipe help on the rows where it ran" instead of
+        // "did pxpipe move my real bill". The first is a cherry-pick.
+        const allBaselineEquiv = this.totals.allBaselineEquivalentWeighted;
+        const allActual = this.totals.allActualInputWeighted;
+        const allOutput = this.totals.allOutputWeighted;
+        // Denominator = counterfactual all-rows bill: what the user would have
+        // paid with no pxpipe. Bounded ratio at 100%; a single cold-miss
+        // compressed request on an otherwise empty session shows ~99% saved,
+        // not 280%.
+        const allCounterfactualBill = allBaselineEquiv + allOutput;
+        const pctAllSpend = allCounterfactualBill > 0 ? (saved / allCounterfactualBill) * 100 : 0;
+        // Direct observed split — actual $ per request, partitioned by which
+        // path ran. Token-equivalent (input × 1.0 + cache_create × 1.25 +
+        // cache_read × 0.10 + output × 5) → $ at the assumed Opus 4.7 input
+        // rate. Same $/Mtok rate is applied to both buckets, so the bias from
+        // the rate assumption cancels in the delta. Selection bias from the
+        // gate is NOT cancelled — the operator interprets that via the
+        // sample-count caveat below.
+        const compressedTokenEquiv = this.totals.compressedActualInputWeighted +
+            this.totals.compressedOutputWeighted;
+        const passthroughTokenEquiv = this.totals.passthroughActualInputWeighted +
+            this.totals.passthroughOutputWeighted;
+        const compressedActualUsd = (compressedTokenEquiv * ASSUMED_INPUT_USD_PER_MTOK) / 1e6;
+        const passthroughActualUsd = (passthroughTokenEquiv * ASSUMED_INPUT_USD_PER_MTOK) / 1e6;
+        const compressedAvgUsd = this.totals.compressedPaidRequests > 0
+            ? compressedActualUsd / this.totals.compressedPaidRequests
+            : 0;
+        const passthroughAvgUsd = this.totals.passthroughPaidRequests > 0
+            ? passthroughActualUsd / this.totals.passthroughPaidRequests
+            : 0;
+        // Sufficient-sample threshold is a soft heuristic. 20 paid requests per
+        // bucket is enough to see a real effect on Opus 4.7 traffic (a single
+        // big cold-miss can dominate at lower n). Below this, the UI shows the
+        // bucket numbers but hides the delta and surfaces "small sample".
+        const SUFFICIENT = 20;
+        const splitSufficient = this.totals.compressedPaidRequests >= SUFFICIENT &&
+            this.totals.passthroughPaidRequests >= SUFFICIENT;
+        const splitDeltaUsd = compressedAvgUsd - passthroughAvgUsd;
+        const uptimeSec = Date.now() / 1000 - this.totals.startedAt;
+        const payload = {
+            requests: this.totals.requests,
+            compressed_requests: this.totals.compressedRequests,
+            baseline_input_weighted: Math.round(baseline),
+            actual_input_weighted: Math.round(actual),
+            saved_input_tokens: Math.round(saved),
+            // saved_pct kept for back-compat with existing dashboard HTML; it is
+            // the input-only number. New code should read saved_pct_input_only.
+            saved_pct: round1(pctInput),
+            saved_pct_input_only: round1(pctInput),
+            saved_pct_of_total_bill: round1(pctTotal),
+            // Honest "share of total bill saved" — measured-rows numerator over
+            // ALL paid requests in the denominator (compressed + passthrough +
+            // probe-failed). This is the number users actually want when they
+            // ask "is pxpipe helping". Negative when flap-pollution from
+            // passthrough turns exceeds the collapse win on measured turns.
+            saved_pct_of_all_spend: round1(pctAllSpend),
+            all_baseline_equivalent_weighted: Math.round(allBaselineEquiv),
+            all_actual_input_weighted: Math.round(allActual),
+            all_output_weighted: Math.round(allOutput),
+            all_usage_requests: this.totals.allUsageRequests,
+            // Direct observed split — replaces "share of spend saved" as the
+            // headline. Total actual $ and average $/req per path, plus a delta
+            // gated on `split_sufficient_sample`. No counterfactual: each
+            // bucket is what each path actually billed.
+            compressed_paid_requests: this.totals.compressedPaidRequests,
+            passthrough_paid_requests: this.totals.passthroughPaidRequests,
+            compressed_actual_usd: round4(compressedActualUsd),
+            passthrough_actual_usd: round4(passthroughActualUsd),
+            compressed_avg_usd_per_request: round4(compressedAvgUsd),
+            passthrough_avg_usd_per_request: round4(passthroughAvgUsd),
+            compressed_minus_passthrough_avg_usd: round4(splitDeltaUsd),
+            split_sufficient_sample: splitSufficient,
+            split_min_sample_per_bucket: SUFFICIENT,
+            saved_usd: round4((saved * ASSUMED_INPUT_USD_PER_MTOK) / 1e6),
+            output_weighted: Math.round(output),
+            baseline_token_equivalent: Math.round(baselineTotal),
+            actual_token_equivalent: Math.round(actualTotal),
+            pricing_assumptions: {
+                input_per_mtok: ASSUMED_INPUT_USD_PER_MTOK,
+                output_multiplier: OUTPUT_TOKEN_RATE,
+                cache_write_5m_multiplier: 1.25,
+                cache_write_1h_multiplier: 2.0,
+                cache_read_multiplier: 0.1,
+                source: 'docs.anthropic.com/en/docs/about-claude/pricing (verified 2026-05-19)',
+            },
+            // Honest output measurement — char counts from the SSE/JSON scanner,
+            // independent of Anthropic's `usage.output_tokens`. Surfaces the gap
+            // the May-2026 weekly-meter audit hypothesized (redacted_thinking adds
+            // billed tokens that we can't see). `events_with_measurement` lets the
+            // operator weigh how representative the numbers are; when it's near
+            // `requests`, the gap is real. When it's 0, the scanner never landed
+            // (5xx-heavy session, no /v1/messages traffic).
+            measured_text_chars: this.totals.textCharsMeasured,
+            measured_thinking_chars: this.totals.thinkingCharsMeasured,
+            measured_tool_use_chars: this.totals.toolUseCharsMeasured,
+            measured_redacted_block_count: this.totals.redactedBlockCountMeasured,
+            events_with_measurement: this.totals.eventsWithMeasurement,
+            uptime_sec: uptimeSec,
+            compression_enabled: this.compressionEnabled,
+        };
+        return new Response(JSON.stringify(payload, null, 2), {
+            headers: { 'content-type': 'application/json' },
+        });
+    }
+    serveRecent() {
+        const latest = this.images[this.images.length - 1];
+        const payload = {
+            recent: this.recent,
+            has_preview: latest !== undefined,
+            preview_meta: latest?.meta ?? '',
+            // Image ids currently resident in the ring. The dashboard uses this to
+            // tell which RecentRow.img_id values still resolve — older ones have
+            // been evicted and their "view" button should be disabled.
+            image_ids: this.images.map((im) => im.id),
+        };
+        return new Response(JSON.stringify(payload), {
+            headers: { 'content-type': 'application/json' },
+        });
+    }
+    /** GET /proxy-latest-png[?id=N] — raw PNG from the image ring. With no id
+     *  (or an unknown id) the latest render is returned; ?id=N pulls that
+     *  specific image while it's still in the ring. 404 once evicted. */
+    servePng(id) {
+        // Cropping is done client-side via CSS (object-position + overflow:hidden).
+        // Python decoded the PNG to crop server-side; we skip that to avoid
+        // pulling a PNG decoder back in — the CSS approach renders identically.
+        const entry = id !== undefined
+            ? this.images.find((im) => im.id === id)
+            : this.images[this.images.length - 1];
+        if (!entry) {
+            return new Response('no image yet', { status: 404 });
+        }
+        return new Response(entry.png, {
+            headers: { 'content-type': 'image/png', 'cache-control': 'no-cache' },
+        });
+    }
+    /** GET /api/image-source[?id=N] — the source text the PNG was rendered
+     *  from, so the operator can see the text → image conversion side by side.
+     *  Falls back to the latest image; 404 if evicted or text wasn't captured. */
+    serveImageSource(id) {
+        const entry = id !== undefined
+            ? this.images.find((im) => im.id === id)
+            : this.images[this.images.length - 1];
+        if (!entry || entry.sourceText === undefined) {
+            return new Response(JSON.stringify({ error: 'no source text' }), {
+                status: 404,
+                headers: { 'content-type': 'application/json' },
+            });
+        }
+        return new Response(JSON.stringify({ id: entry.id, meta: entry.meta, source_text: entry.sourceText }), { headers: { 'content-type': 'application/json' } });
+    }
+    serveHtml(port) {
+        return htmlResponse(renderPage(port));
+    }
+    /** GET /fragments/<name> — server-rendered htmx fragments. Each one reuses
+     *  the corresponding JSON endpoint's payload (via Response.json()) so the
+     *  HTML and JSON surfaces can't drift apart. */
+    async serveFragment(name, url, port) {
+        switch (name) {
+            case 'toggle':
+                return htmlResponse(renderToggleFragment(this.compressionEnabled));
+            case 'models':
+                return htmlResponse(renderModelsFragment(getAllowedModelBases(), getConfiguredModelBases(), this.compressionEnabled));
+            case 'context-map': {
+                const reqParam = url.searchParams.get('req');
+                if (reqParam) {
+                    // Explicit request: show ONLY that one. If its breakdown was evicted
+                    // or never recorded (no usage on that completion), say so — don't
+                    // silently fall back to the latest request's data under its label.
+                    const found = this.contextHistory.find((h) => h.id === Number(reqParam));
+                    return htmlResponse(renderContextMapFragment(found, this.contextHistory, !found));
+                }
+                // No specific request → default to the latest.
+                return htmlResponse(renderContextMapFragment(this.contextHistory[this.contextHistory.length - 1], this.contextHistory));
+            }
+            case 'session-summary': {
+                // Lifetime hero — same cumulative payload as the header strip so the
+                // headline and the "$ saved" tiles never disagree and it stops jumping.
+                const s = (await this.serveStats().json());
+                return htmlResponse(renderSessionSummaryFragment(s));
+            }
+            case 'header': {
+                const s = (await this.serveStats().json());
+                return htmlResponse(renderHeaderFragment(s, port));
+            }
+            case 'recent': {
+                const r = (await this.serveRecent().json());
+                return htmlResponse(renderRecentFragment(r));
+            }
+            case 'latest': {
+                const r = (await this.serveRecent().json());
+                const pinRaw = url.searchParams.get('pin');
+                const pinNum = pinRaw != null && pinRaw !== '' ? Number(pinRaw) : NaN;
+                const pin = Number.isFinite(pinNum) ? pinNum : null;
+                const showSource = url.searchParams.get('source') === '1';
+                let sourceText = null;
+                if (showSource) {
+                    const entry = pin != null
+                        ? this.images.find((im) => im.id === pin)
+                        : this.images[this.images.length - 1];
+                    sourceText = entry?.sourceText ?? null;
+                }
+                return htmlResponse(renderLatestFragment({ payload: r, pin, showSource, sourceText }));
+            }
+            case 'sessions': {
+                const res = await this.serveSessionsJson();
+                if (!res.ok)
+                    return htmlResponse(`<div class="status">sessions unavailable</div>`);
+                const p = (await res.json());
+                return htmlResponse(renderSessionsFragment(p));
+            }
+            case 'stats': {
+                const res = await this.serveApiStats();
+                const p = (await res.json());
+                return htmlResponse(renderStatsTableFragment(p));
+            }
+            default:
+                return new Response('unknown fragment', { status: 404 });
+        }
+    }
+    // ---- session / cleanup endpoints --------------------------------------
+    //
+    // Every endpoint below recomputes from disk on demand. The dashboard polls
+    // these on a 5s cadence, which is fine for a single-user dev tool — even at
+    // ~3k events / 1.5 MB the round-trip is <100ms on a warm SSD.
+    /** GET /api/sessions.json — grouped sessions enriched with the Claude Code
+     *  cross-reference. The body is the top-level `sessions` array; the client
+     *  renders a bar chart of the top savers. */
+    async serveSessionsJson(opts = {}) {
+        if (!this.paths)
+            return notConfigured('sessions');
+        const [{ sessions }, ccMap] = await Promise.all([
+            aggregateSessions(this.paths),
+            this.ccMapFn(),
+        ]);
+        const rows = filterSessions(sessions, opts);
+        const enriched = rows.map((s) => ({
+            ...s,
+            claudeCode: ccMap.get(s.id) ?? null,
+        }));
+        return jsonResponse({ sessions: enriched, count: enriched.length });
+    }
+    /** GET /api/stats.json — full-history aggregate. Migrated from the
+     *  former `pxpipe stats` CLI. */
+    async serveApiStats() {
+        if (!this.paths)
+            return notConfigured('stats');
+        const result = await aggregateEventsFile(this.paths.eventsFile);
+        if (!result) {
+            return jsonResponse({
+                error: 'no events file yet',
+                path: this.paths.eventsFile,
+            }, 404);
+        }
+        return jsonResponse({
+            parsed: result.parsed,
+            dropped: result.dropped,
+            summary: summaryToJson(result.summary),
+        });
+    }
+    /** POST /api/compression — flip the runtime kill switch.
+     *  Body: { enabled: boolean }. Returns the new state. In-memory only;
+     *  restart resets to the default (on). */
+    handleCompressionToggle(body) {
+        const on = body.enabled === true;
+        this.compressionEnabled = on;
+        return jsonResponse({ compression_enabled: on });
+    }
+    /** POST /fragments/models — add/remove ONE model (Claude or GPT) from the
+     *  runtime compress scope. In-memory only; restart resets to the PXPIPE_MODELS
+     *  env / built-in default. The model checks read this live. */
+    handleModelsToggle(model, on) {
+        const next = new Set(getAllowedModelBases());
+        if (on)
+            next.add(model);
+        else
+            next.delete(model);
+        setAllowedModelBases([...next]);
+    }
+}
+function jsonResponse(body, status = 200) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: {
+            'content-type': 'application/json',
+        },
+    });
+}
+function notConfigured(what) {
+    // The dashboard was constructed without SessionsPaths (e.g. a legacy host
+    // that doesn't track to disk). Return 503 so the client can surface a
+    // helpful error rather than failing silently.
+    return jsonResponse({ error: `${what} unavailable: dashboard not configured with event paths` }, 503);
+}
+function round1(n) {
+    return Math.round(n * 10) / 10;
+}
+function round4(n) {
+    return Math.round(n * 10000) / 10000;
+}
+/** Match dashboard paths (handle query strings on /proxy-latest-png). */
+export function dashboardPath(pathname) {
+    if (pathname === '/' || pathname === '/dashboard')
+        return { kind: 'html' };
+    if (pathname === '/proxy-stats')
+        return { kind: 'stats' };
+    if (pathname === '/proxy-recent')
+        return { kind: 'recent' };
+    if (pathname === '/proxy-latest-png')
+        return { kind: 'png' };
+    if (pathname === '/api/sessions.json')
+        return { kind: 'api-sessions' };
+    if (pathname === '/api/stats.json')
+        return { kind: 'api-stats' };
+    if (pathname === '/api/current-session.json')
+        return { kind: 'current-session' };
+    if (pathname === '/api/compression')
+        return { kind: 'api-compression' };
+    if (pathname === '/api/image-source')
+        return { kind: 'api-image-source' };
+    if (pathname.startsWith('/fragments/')) {
+        return { kind: 'fragment', name: pathname.slice('/fragments/'.length) };
+    }
+    return null;
+}
+function htmlResponse(body) {
+    return new Response(body, {
+        headers: { 'content-type': 'text/html; charset=utf-8' },
+    });
+}
+//# sourceMappingURL=dashboard.js.map