@agentguard-run/burn 0.2.7 → 0.3.1

package/dist/src/render-recording.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCanvasPng = renderCanvasPng;
+exports.renderRecording = renderRecording;
+/** Offline PNG and video rendering from validated, recorded Canvas data. */
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const node_path_1 = require("node:path");
+const canvas_1 = require("@napi-rs/canvas");
+const canvas_2 = require("./canvas");
+const frames_1 = require("./frames");
+const recording_1 = require("./recording");
+const run = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const CELL_WIDTH = 18, CELL_HEIGHT = 28;
+const FONT_ALIAS = 'BurnRecordingMono';
+const FONT_PATHS = [
+    '/System/Library/Fonts/Menlo.ttc',
+    '/Library/Fonts/Menlo.ttc',
+    '/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf',
+    '/usr/share/fonts/dejavu-sans-mono-fonts/DejaVuSansMono.ttf',
+    '/usr/share/fonts/TTF/DejaVuSansMono.ttf',
+];
+async function font() {
+    for (const path of FONT_PATHS) {
+        try {
+            await (0, promises_1.access)(path, node_fs_1.constants.R_OK);
+            if (canvas_1.GlobalFonts.registerFromPath(path, FONT_ALIAS) && canvas_1.GlobalFonts.has(FONT_ALIAS))
+                return path;
+        }
+        catch { /* Try the next installed local font. */ }
+    }
+    throw new Error('Recording render needs an installed Menlo or DejaVu Sans Mono font; no font was downloaded.');
+}
+async function executable(requested) {
+    const paths = (0, node_path_1.isAbsolute)(requested) || requested.includes('/') || requested.includes('\\')
+        ? [(0, node_path_1.resolve)(requested)] : (process.env.PATH || '').split(node_path_1.delimiter).filter(Boolean).map(path => (0, node_path_1.resolve)(path, requested));
+    for (const path of paths) {
+        try {
+            await (0, promises_1.access)(path, node_fs_1.constants.X_OK);
+            if ((await (0, promises_1.lstat)(path)).isFile() || (await (0, promises_1.lstat)(path)).isSymbolicLink())
+                return path;
+        }
+        catch { /* Not on this PATH entry. */ }
+    }
+    return null;
+}
+async function requireUnused(path) {
+    try {
+        await (0, promises_1.lstat)(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+    throw new Error(`Refusing to overwrite existing output: ${path}`);
+}
+/** For display only; execution always passes an argument array without a shell. */
+function shellWord(value) { return `'${value.replace(/'/g, "'\\''")}'`; }
+/** FFmpeg represents concat timestamps in microseconds; Date.parse truncates below milliseconds. */
+function timestampMicros(at) {
+    const milliseconds = Date.parse(at);
+    if (!Number.isFinite(milliseconds))
+        throw new Error('Recording timestamps must be valid and ordered.');
+    const fraction = /\.(\d+)(?:Z|[+-]\d{2}:?\d{2})$/i.exec(at)?.[1] ?? '';
+    return BigInt(milliseconds) * 1000n + BigInt(fraction.slice(3, 6).padEnd(3, '0'));
+}
+async function renderCanvasPng(snapshot, width = 1920, height = 1080) {
+    await font();
+    if (!Number.isInteger(width) || !Number.isInteger(height) || width < 64 || height < 64 || width > 4096 || height > 4096)
+        throw new Error('Canvas raster dimensions must be integers between 64 and 4096.');
+    const canvas = (0, canvas_1.createCanvas)(width, height);
+    const cellWidth = Math.min(CELL_WIDTH, Math.max(1, Math.floor((width - 32) / snapshot.width)));
+    const cellHeight = Math.min(CELL_HEIGHT, Math.max(1, Math.floor((height - 32) / snapshot.height)), Math.round(cellWidth * CELL_HEIGHT / CELL_WIDTH));
+    const paddingX = Math.floor((canvas.width - snapshot.width * cellWidth) / 2);
+    const paddingY = Math.floor((canvas.height - snapshot.height * cellHeight) / 2);
+    const ctx = canvas.getContext('2d');
+    ctx.fillStyle = '#0B1117';
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+    ctx.font = `${26 * cellWidth / CELL_WIDTH}px "${FONT_ALIAS}"`;
+    ctx.textBaseline = 'alphabetic';
+    for (let row = 0; row < snapshot.height; row++)
+        for (let col = 0; col < snapshot.width; col++) {
+            const cell = snapshot.cells[row][col];
+            if (cell.char === ' ')
+                continue;
+            ctx.fillStyle = canvas_2.CANVAS_PALETTE[cell.color === 'none' ? 'white' : cell.color].hex;
+            const x = paddingX + col * cellWidth, y = paddingY + row * cellHeight;
+            if (cell.char === '█')
+                ctx.fillRect(x, y, cellWidth, cellHeight);
+            else if (cell.char === '▀')
+                ctx.fillRect(x, y, cellWidth, cellHeight / 2);
+            else if (cell.char === '▄')
+                ctx.fillRect(x, y + cellHeight / 2, cellWidth, cellHeight / 2);
+            else if (cell.char === '─')
+                ctx.fillRect(x, y + cellHeight / 2, cellWidth, 1);
+            else
+                ctx.fillText(cell.char, x + 1, y + 23 * cellHeight / CELL_HEIGHT, Math.max(1, cellWidth - 2));
+        }
+    return canvas.encode('png');
+}
+async function renderRecording(source, options) {
+    const sourcePath = (0, node_path_1.resolve)(source), mp4Path = (0, node_path_1.resolve)(options.mp4);
+    const gifPath = options.gif ? (0, node_path_1.resolve)(options.gif) : null;
+    const provenancePath = `${mp4Path}.provenance.json`;
+    for (const path of [sourcePath, mp4Path, provenancePath, ...(gifPath ? [gifPath] : [])]) {
+        if (/[\x00-\x1f\x7f]/.test(path))
+            throw new Error('Recording paths must not contain control characters.');
+    }
+    if (new Set([sourcePath, mp4Path, provenancePath, ...(gifPath ? [gifPath] : [])]).size !== (gifPath ? 4 : 3)) {
+        throw new Error('Recording source and each output must use different paths.');
+    }
+    for (const path of [mp4Path, provenancePath, ...(gifPath ? [gifPath] : [])])
+        await requireUnused(path);
+    const sourceStat = await (0, promises_1.stat)(sourcePath);
+    if (!sourceStat.isFile() || sourceStat.size > 128 * 1024 * 1024)
+        throw new Error('Recording must be a regular local file no larger than 128 MB.');
+    const sourceBytes = await (0, promises_1.readFile)(sourcePath);
+    const frames = await (0, recording_1.readRecording)(sourcePath);
+    if (!frames.length)
+        throw new Error('Recording contains no frames.');
+    const times = frames.map(frame => timestampMicros(frame.at));
+    const videoIndices = [];
+    for (let index = 0; index < frames.length; index++) {
+        if (index && times[index] < times[index - 1])
+            throw new Error('Recording timestamps must be valid and ordered.');
+        // No elapsed time exists between equal timestamps. Keep the latest state in video,
+        // while retaining every observation as its own PNG and provenance entry.
+        if (index === frames.length - 1 || times[index] !== times[index + 1])
+            videoIndices.push(index);
+    }
+    if (!sourceBytes.equals(await (0, promises_1.readFile)(sourcePath)))
+        throw new Error('Recording changed while it was being read; render the saved file again.');
+    const sourceHash = (0, node_crypto_1.createHash)('sha256').update(sourceBytes).digest('hex');
+    const fontPath = await font();
+    await (0, promises_1.mkdir)((0, node_path_1.dirname)(mp4Path), { recursive: true });
+    if (gifPath)
+        await (0, promises_1.mkdir)((0, node_path_1.dirname)(gifPath), { recursive: true });
+    const framesDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_path_1.dirname)(mp4Path), `${(0, node_path_1.basename)(mp4Path)}.frames-`));
+    const concatPath = (0, node_path_1.join)(framesDir, 'frames.ffconcat');
+    const lines = ['ffconcat version 1.0'];
+    for (let index = 0; index < frames.length; index++) {
+        const frame = frames[index];
+        const name = `frame-${String(index).padStart(6, '0')}.png`;
+        const image = (0, frames_1.renderFrame)(frame.data, { recorded: true, at: frame.at, width: frame.viewport?.width ?? 104, height: frame.viewport?.height ?? 35, colour: true });
+        await (0, promises_1.writeFile)((0, node_path_1.join)(framesDir, name), await renderCanvasPng(image.toJSON()), { flag: 'wx', mode: 0o600 });
+    }
+    for (const [position, index] of videoIndices.entries()) {
+        const next = videoIndices[position + 1];
+        const seconds = next === undefined ? 1 : Number(times[next] - times[index]) / 1_000_000;
+        lines.push(`file 'frame-${String(index).padStart(6, '0')}.png'`, 'option framerate 1000000', `duration ${seconds.toFixed(6)}`);
+    }
+    // The concat demuxer needs a terminal file to honor the final frame hold.
+    lines.push(`file 'frame-${String(frames.length - 1).padStart(6, '0')}.png'`, 'option framerate 1000000');
+    await (0, promises_1.writeFile)(concatPath, `${lines.join('\n')}\n`, { flag: 'wx', mode: 0o600 });
+    const ffmpeg = options.ffmpeg === null ? null : await executable(options.ffmpeg || 'ffmpeg');
+    const common = ['-hide_banner', '-loglevel', 'error', '-nostdin', '-n', '-protocol_whitelist', 'file,pipe', '-f', 'concat', '-safe', '0', '-i', concatPath];
+    // B-frame reordering can collapse the MP4 track duration to rapid DTS steps even
+    // when the final presentation timestamp correctly includes the one-second hold.
+    const mp4Args = [...common, '-fps_mode', 'vfr', '-c:v', 'libx264', '-bf', '0', '-enc_time_base', '1:1000000', '-video_track_timescale', '1000000', '-pix_fmt', 'yuv420p', '-movflags', '+faststart', mp4Path];
+    const gifArgs = [...common, '-fps_mode', 'vfr', '-frames:v', String(videoIndices.length), '-final_delay', '100', '-vf', 'split[a][b];[a]palettegen[p];[b][p]paletteuse', '-loop', '0', ...(gifPath ? [gifPath] : [])];
+    const command = [ffmpeg || 'ffmpeg', ...mp4Args].map(shellWord).join(' ')
+        + (gifPath ? `\n${[ffmpeg || 'ffmpeg', ...gifArgs].map(shellWord).join(' ')}` : '');
+    const provenance = {
+        source_sha256: sourceHash,
+        renderer_version: require('../../package.json').version,
+        rendered_at: new Date().toISOString(),
+        font: { family: FONT_ALIAS, path: fontPath },
+        frame_count: frames.length,
+        frame_times: frames.map(frame => frame.at),
+        frame_viewports: frames.map(frame => frame.viewport ?? { width: 104, height: 35 }),
+        video_frame_indices: videoIndices,
+        video_timestamp_precision: 'microseconds; equal timestamps retain the last frame in video and every PNG',
+        final_hold_seconds: 1,
+        gif_timestamp_precision: 'centiseconds; terminal concat sentinel excluded; final displayed frame holds one second',
+        ffmpeg_command: command,
+        format: 'Recorded viewport (legacy 104x35), centered 18x28 pixel cells, 1920x1080 PNG',
+        video_status: ffmpeg ? 'rendering' : 'ffmpeg_unavailable_png_frames_written',
+    };
+    await (0, promises_1.writeFile)(provenancePath, `${JSON.stringify(provenance, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
+    if (ffmpeg) {
+        try {
+            await run(ffmpeg, mp4Args, { timeout: 300_000, maxBuffer: 1024 * 1024 });
+            if (gifPath)
+                await run(ffmpeg, gifArgs, { timeout: 300_000, maxBuffer: 1024 * 1024 });
+            provenance.video_status = 'complete';
+        }
+        catch (error) {
+            provenance.video_status = 'failed_png_frames_written';
+            throw new Error(`Video encoding failed; PNG frames remain at ${framesDir}: ${error.message}`);
+        }
+        finally {
+            await (0, promises_1.writeFile)(provenancePath, `${JSON.stringify(provenance, null, 2)}\n`, { mode: 0o600 });
+        }
+    }
+    return { framesDir, provenancePath, mp4: ffmpeg ? mp4Path : null, gif: ffmpeg && gifPath ? gifPath : null, ffmpegCommand: command, frameCount: frames.length };
+}

package/dist/src/replay/render.js

@@ -10,6 +10,7 @@ exports.comparison = comparison;
 exports.renderReplay = renderReplay;
 exports.renderStop = renderStop;
 exports.renderSessionRow = renderSessionRow;
+const frames_1 = require("../frames");
 const evaluate_1 = require("../detectors/evaluate");
 const C = {
     reset: '\x1b[0m',
@@ -117,6 +118,8 @@ function scenarioUsd(tokens, cacheShare) {
 }
 function renderReplay(summary, opts = {}) {
     const on = opts.colour ?? Boolean(process.stdout.isTTY);
+    if (on)
+        return (0, frames_1.renderFrame)({ kind: 'replay', summary }, { colour: true }).render();
     const top = opts.top ?? 6;
     const out = [];
     const cacheShare = summary.totalTokens
@@ -175,6 +178,8 @@ function renderReplay(summary, opts = {}) {
 // ---------------------------------------------------------------------------
 function renderStop(report, opts = {}) {
     const on = opts.colour ?? false;
+    if (on)
+        return (0, frames_1.renderFrame)({ kind: 'report', report, subject: opts.subject, outcome: 'blocked' }, { colour: true }).render();
     const lead = report.findings.find((f) => f.verdict === 'STOP')?.summary ?? 'Fan-out ceiling reached.';
     const w = 64;
     const bar = '─'.repeat(w);

package/dist/src/types.d.ts

@@ -80,6 +80,10 @@ export interface BurnReport {
     };
 }
 export interface Thresholds {
+    /** Additive local idle-resource warnings; no automatic process termination. */
+    idle_session_warn_hours?: number;
+    idle_browser_warn_minutes?: number;
+    orphan_workspace_warn_days?: number;
     fanout: {
         warn: number;
         stop: number;
@@ -131,6 +135,8 @@ export interface Thresholds {
 }
 export type Mode = 'shadow' | 'enforce';
 export interface Policy {
+    /** Shared threshold file; relative paths resolve from the Burn home. */
+    teamPolicyFile?: string;
     mode: Mode;
     thresholds: Thresholds;
     /** Additive local usage advisories. Older policy files use these defaults. */

package/docs/LIVE_PANEL_2026_09.md

@@ -0,0 +1,55 @@
+# Burn live instrument panel
+
+`agentguard-burn live` reads the local session cache and decision ledgers every half second. It does not change admission, write session state, or open a socket. Use `--session ID` to select a session, `--once` for one frame, and `--record run.jsonl` for a local structured recording. `q` quits and `p` pauses display updates. An observed STOP holds its reason for two seconds while intake continues, then releases the latest view.
+
+```sh
+agentguard-burn live --session e86f091b --record local-run.jsonl
+agentguard-burn live --replay local-run.jsonl
+agentguard-burn render local-run.jsonl --mp4 local-run.mp4 --gif local-run.gif
+```
+
+The panel uses the existing Canvas and palette. SPAWNS and TOKENS IN WINDOW are observed bucket sums over the policy's active-minute window, including inherited team thresholds. The rate bar becomes amber at 80 percent of the configured STOP ceiling and red at the ceiling. REPLAY SHARE is session cache-read tokens divided by all observed tokens. It is a cache-read proxy, not measured repeated semantic work. No numeric value is synthesized when the corresponding source is unavailable.
+
+The right column shows the last eight locally recorded decisions. Historical ledgers record an action such as `spawn`, rather than the host's precise tool name; the panel displays that action. At fewer than 80 columns the right column is omitted, leaving full-width counters and the STOP card. The tested geometries are 104x35, 80x24 and a 43-column compact view rendered natively at 390 pixels.
+
+Colored STOP reports use the same panel without reading files or delaying a hook. Their missing token-window, window-length and elapsed values remain unknown. They do not claim a two-second interactive hold. Existing plain-text cards and hook protocol bytes use their previous paths.
+
+## Verification
+
+The full Node22 suite passed **265/265**, zero failures or skips, with `AGENTGUARD_STRESS=1`. The fixture stress test admitted exactly 40 of 240 concurrent hooks, denied 200, and verified the receipt chain. Full output is retained in `/private/tmp/burn-rulepack-panel-tests-final.log`. The first sandboxed attempt could not bind its local conformance server; the full permitted rerun passed.
+
+## September 19 evidence
+
+The site figure comes from `assets/stop-capture.txt` and `docs/redesign-2026-09/hero/REPORT.md`, which explicitly disclose prepared synthetic history and a real hook decision (receipt `4cb15245-a57e-463c-aed5-32b143c5d719`). The older `docs/STOP_CLIP_2026-09.md` describes another prepared capture. Those captures do not establish a naturally observed rate storm.
+
+The search covered all 13 receipts and 148 decision rows in the current local Burn ledgers, not only the selected session. September 19 UTC contains 11 rows in each ledger and two STOPs; September 19 Pacific contains 12 rows and one STOP. Every STOP uses fanout plus duplicate-work; neither date scope contains a spawn-rate finding. The evidence file records source hashes and both date boundaries. This search does not claim coverage of deleted or alternate-home ledgers.
+
+The actual signed receipt is `d2f3ceec-816c-41ad-9e1d-23401eeb44f3`, session digest `3fa090ccbdfeaaa5de7b660af6dfb8dddfac5112e7a95188a0be494a90740263`. Ed25519 verification passed. Its timestamp is `2026-09-19T14:56:57.824Z`. The gate was historical **lifetime fanout: 48 proposed spawns against 40**, with a duplicate-work WARN. It was not the current 16-spawns-per-15-active-minutes gate.
+
+The current deduplicating reader, restricted to the receipt timestamp, finds 47 observed spawns, 1,628,919,976 total tokens and 1,599,279,923 cache-read tokens. Its final 15-active-minute window has **one spawn and 8,086,525 tokens**. These are a fresh reconstruction from the parent and its 45 child transcripts. They are not the historical inflated usage totals retained in the signed receipt. Live state and policy were not rewritten.
+
+The bounded clip starts at the real usage observation `14:56:18.247Z`. The next observed spawn is at `14:56:57.749Z`, followed 75 milliseconds later by the signed block. The counters show the actual zero-to-one spawn change. The reference rate bar stays below 16. The requested storm and rate-ceiling crossing cannot be substantiated from this event.
+
+Original observation times are preserved. One-second display-clock ticks add no observations. The STOP card remains for two seconds, followed by the renderer's one-second final frame. The source observation interval lasts 39.577 seconds; the MP4 lasts 42.577001 seconds. GIF stores centisecond timing and lasts 42.58 seconds. Earlier session activity and later observations are outside the clip; prior decision rows provide context. Every frame says `RECORDED RUN · 1x`.
+
+Assets live in `docs/assets/`:
+
+- `burn-live-sep19.mp4` and `burn-live-sep19.gif`: 1920x1080.
+- `burn-live-sep19-stop-1920.png`: the actual STOP frame.
+- `burn-live-sep19-stop-390.png`: native compact Canvas rendering at 390x540.
+- `burn-live-sep19.jsonl`: content-free frames written through the actual `live --replay --record` command.
+- `burn-live-sep19.observations.jsonl`: the reconstructed input; CLI output preserves its frame data, timestamps and viewport exactly.
+- `burn-live-sep19.receipt.json`: original signed receipt.
+- `burn-live-sep19.evidence.json`: input hashes, receipt verification, timing, omissions, and media hashes.
+- `burn-live-sep19.mp4.provenance.json`: renderer, font, frame times and encoding command.
+
+Re-render the shipped recording without reading any private session data:
+
+```sh
+agentguard-burn live --replay docs/assets/burn-live-sep19.jsonl --once --no-color --record /tmp/burn-review.jsonl
+agentguard-burn render /tmp/burn-review.jsonl --mp4 /tmp/burn-review.mp4 --gif /tmp/burn-review.gif
+```
+
+The non-TTY replay above checks the recording path; its stdout is not a timed terminal capture. The rendered media uses the original frame timestamps. The showcase itself was run through this CLI path, with frame equality checked before encoding.
+
+Reconstruct with `npm run build` then `node scripts/record-september19.cjs /tmp/burn-september19-review`. The script requires the matching verified local receipt and transcripts and refuses to overwrite outputs. It exports numbers, opaque identifiers, action labels and detector reasons. It does not export tool inputs, outputs, prompts, source paths or file contents.

package/docs/assets/burn-live-sep19.evidence.json

@@ -0,0 +1,288 @@
+{
+  "receipt_verified": true,
+  "ledger_search": [
+    {
+      "ledger": "receipts.ndjson",
+      "scope": "UTC",
+      "total_rows": 13,
+      "date_rows": 11,
+      "stop_rows": 2,
+      "spawn_rate_rows": 0
+    },
+    {
+      "ledger": "receipts.ndjson",
+      "scope": "Pacific",
+      "total_rows": 13,
+      "date_rows": 12,
+      "stop_rows": 1,
+      "spawn_rate_rows": 0
+    },
+    {
+      "ledger": "decisions.ndjson",
+      "scope": "UTC",
+      "total_rows": 148,
+      "date_rows": 11,
+      "stop_rows": 2,
+      "spawn_rate_rows": 0
+    },
+    {
+      "ledger": "decisions.ndjson",
+      "scope": "Pacific",
+      "total_rows": 148,
+      "date_rows": 12,
+      "stop_rows": 1,
+      "spawn_rate_rows": 0
+    }
+  ],
+  "site_capture_sources": [
+    {
+      "relative_path": "assets/stop-capture.txt",
+      "sha256": "9da285376fe618a3130955c31c7ab3d35b5e6de45963da0a9911ccaea707ea09",
+      "discloses_prepared_history": true
+    },
+    {
+      "relative_path": "docs/redesign-2026-09/hero/REPORT.md",
+      "sha256": "b84096959799fa04041b426024d561347239f83fe30890b8618cf96f47dbce5d",
+      "discloses_prepared_history": true
+    },
+    {
+      "relative_path": "docs/STOP_CLIP_2026-09.md",
+      "sha256": "71f11b67e9fb7b52941bc32ac557eedfbf7ca9fa8cf3d9e0d3b286aca98b41b0",
+      "discloses_prepared_history": true
+    }
+  ],
+  "cli_recording": {
+    "command": "agentguard-burn live --replay burn-live-sep19.observations.jsonl --once --no-color --record burn-live-sep19.jsonl",
+    "frame_data_timestamps_and_viewport_identical": true,
+    "stdout_is_not_a_timed_capture": true
+  },
+  "receipt_sha256": "b46871a3cfeb203fababf81946d30acd22479b7b2af616370092c712d9da948c",
+  "receipt_id": "d2f3ceec-816c-41ad-9e1d-23401eeb44f3",
+  "session_digest": "3fa090ccbdfeaaa5de7b660af6dfb8dddfac5112e7a95188a0be494a90740263",
+  "receipts_ledger_sha256": "b7fa92561e0e9d9a201eebe031a90ed4106dae020d4645506b342ecc09065898",
+  "decisions_ledger_sha256": "503331af4e695f28f830302805558075c640f428b52246422c55419bbd3741cd",
+  "source_files": [
+    {
+      "role": "parent transcript",
+      "sha256": "e03804372ffa73c526b863096261d9020ff6d1f4ec6ec49d257c843b430a05cd"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "fb72efad9b6a3a3f892cc7cdfb13c5e6ce2f6a100b42c1e9ec8f35b08c23c6ed"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "a177e5d3f2b2ac692e3855ecc7a956873f327fc25aadf502bfe61eb24a79d7f0"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "9a2ec39f738ac309a7562f935484f7d74432571a75ba7a78de12b02a6cb7b201"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "5e962fbc8a654b1980dc41fe600638d20778146807cee149f8d7112a99b58e7a"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "24cfb0864c80c3e7195942c4ed2ef85b561ed09f5e51f65002e6d2256bbb6199"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "283eea347311a0458b899e0c6bb97dc516b1480dc744c66a18fd7ce5fa6aaa5e"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "5d980691f48e18d853da98c3afbef5bb6cc6d9202f2dde44b745e16395d3e452"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "49d1fc94f4dbdb395f341271b9ef53a3a25166985923a5f0c5113a80df74f47a"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "f2d02db65cdc10b429c928e7f270ff6278058a6375d593418f78d1b7f9d2f237"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "b11301e2a2a47607b7450de56f6fef328d2b461fd2102493dcd318c530bfca9f"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "5b49e66fc92a0a9206460f225eb545896e51df91d0050eb6caf29e4c373a2d1f"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "4361b129375583a79da9580bcbb3be8065efb08e917ab4281334a19a1907300d"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "ce22debd96b8d85c612dd12d3f3ebf97508f52c95d41470dc3e69a81edd516d0"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "31d1b33e684a143879742dfaa2d703903b44d661310e528117a6df9eaedfd58d"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "e9dbc8b6eda13e8ca545bcb25dae13d502bf569ac638f8202f45791d66128a7e"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "88ea801434684e01ebe3d9b159ca38e0ddd813f24a3f8271e581496edb37214d"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "93b3fbf110320d0a54307a0dd265e53a374a70218333baeacc0262ebdcdffaa9"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "dbc3df30407aae1d14ae1053e954e57588e17f933013f5ecf41b06fedfb3a028"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "796c81f284d2a0be91c05393797ef8a891a9f20baad841449a4d3e434e0df33b"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "4894840661069bbe53ee7304740113e3ed8aca4c7ac180f61acd8b112faed08f"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "bafd6a55cfd94a992ae4890ee845b0fc7f49b4410f23896afc7f83ec0cbeb494"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "e04cc31b3b80dd3b775a534a15ab0b8fef7fc8cfd65f827780e9e0acd29eb4e3"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "fe9e02cba15dbfe7676d89d3510f422b8acc8b1f026b8d8f37b5477ce2049c23"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "593738b8533015d9504033b0afe66e123b6aedfe71e69ebbaec2f80c422ce2f8"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "11da50efa0d68b99fc1c3f39c21f1192d88d631174c98500a3a224e35ca3de0c"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "3543da8cb0dc23998cdfb048d8576b98be1562ea2c585055433e3c95fe3eb051"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "c6460a8f8d6071af147957033c86b60fbaa684a653ff5743a8261112dc495a41"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "5543a25e5979c136308bd1c49b5d20eef53851a01f5a622e5d9b72d9c01ca399"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "9833600b9338c297a8fe86d6ae8d783f80403a8510f6b1192baaa03a0736a5bc"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "d0d1e705d3b000d91df754fea2c0af93074529980500d94f53e83aac6eefe400"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "17848e0ba0d0ee2508ff824478144a435a7b7d12e66c3cb255a1805b84ef5e47"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "a5ed36b7d17ec3da2e98ef8e3bb0456e894d18e918012f679ca45a03c0971e84"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "e7afa6e688eeb97c224cd687639191bfb5730f77ae2c0f426d253b90d7f22416"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "884764f0a6ac584da1a34c2c60270efc068e3b5c1f4cad79d92a5baf1d6151c0"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "835365b6736af0c6389925d8490d5a173773093d4cab6a5be0481f97d8c58e73"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "454038ed5bf3aec9183bf955ccc8cea9e77ca512a5fcbbf0db9fb4d04795f100"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "862a476a9ce4ca026d251216d76549a2fcb46d5421851ed6ac29efb56ebaf169"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "082a34a2d20f9c696de84d70c6b24afe72612c2ff588d86f7e07ead995194767"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "78a319db493ac9f052551d71c6118fd8ba658080b2b4915a5683d808d66c07b9"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "bfb1bd3e7281a3ac79a6c3bd4dbe40e149997e45b82b1e05c05892e888f2730f"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "613a74992c51ff6cf42d073e314c938c5484769b1c2b384a431b6a260c68f154"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "9f08151f521f16e5795856c32d6206df7c84fb2be7c503a5061ad387298a4623"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "3b8c3bce6332be6facf9b2e961580ed21ba69e157d9d0fec0902d15516d61abd"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "6e953d95757b5924fc8534712e20be460a7987ff9c0d31dd6cd5bfb88dc56e96"
+    },
+    {
+      "role": "child transcript",
+      "sha256": "5e50d304214b48d9023b4c32fa85c01e3de80f1679c21f3afc8301d538265d4f"
+    }
+  ],
+  "clip_start": "2026-09-19T14:56:18.247Z",
+  "signed_stop_at": "2026-09-19T14:56:57.824Z",
+  "clip_end": "2026-09-19T14:56:59.824Z",
+  "original_observation_times": [
+    "2026-09-19T14:56:18.247Z",
+    "2026-09-19T14:56:57.749Z"
+  ],
+  "display_ticks": "One-second display-clock ticks plus original transcript and receipt timestamps. Counts change only at original observations. No time compression.",
+  "historical_gate": {
+    "detector": "fanout",
+    "scope": "lifetime",
+    "observed": 48,
+    "threshold": 40
+  },
+  "current_reader_at_block": {
+    "total_tokens": 1628919976,
+    "total_cache_read": 1599279923,
+    "completed_spawns": 47,
+    "window_spawns": 1,
+    "window_tokens": 8086525
+  },
+  "measurement": "Current deduplicating readAll reader, session plus its own child transcripts, filtered through the signed receipt timestamp. No live state was rewritten.",
+  "limits": [
+    "The requested 16-spawns-in-15-active-minutes storm is not supported by this event. The displayed current-reference rate bar remains below its ceiling.",
+    "The historical receipt retains legacy inflated token totals. The panel uses a fresh deduplicated recount, not those legacy totals.",
+    "All observations before the clip start and after the signed block are outside this bounded clip. Prior decisions remain visible as historical context.",
+    "The stored decision rows name the action spawn, not the host tool name. No tool name is invented.",
+    "Replay share means session cache-read tokens divided by all observed tokens. It is a proxy, not a measurement of repeated semantic work.",
+    "The display holds the STOP reason for two seconds after the signed timestamp. The renderer then holds the final released frame for one second."
+  ],
+  "output_sha256": {
+    "burn-live-sep19.jsonl": "2404866fa112d9423918b1d4612bf2c853191c7c5b2a1b4066d667fc53b4127d",
+    "burn-live-sep19.observations.jsonl": "1649ba637a7a528aca977a705aa1a90e19a50f6b12de98572615d8f1d6361a8f",
+    "burn-live-sep19-stop-390.png": "e6bf186febff7849ddd696f2632e438813dfb2019720bd740fdae22235df12d8",
+    "burn-live-sep19.mp4": "c9459e58dfaa18685c0622512178385ed8bd19ed045df14e34935cdab494f697",
+    "burn-live-sep19.gif": "bbc6c701e31b2089fa921b8ecd599d5df74e5201162f9471a2e0c75a2fd663f6",
+    "burn-live-sep19-stop-1920.png": "54e2c10b857b11987a9fd23c2b4c312eb254b1b3308199047dc0f8192e5bf191"
+  }
+}