@agentguard-run/burn 0.3.1 → 0.3.2

package/dist/src/record-ledger.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ledgerTimestamp = ledgerTimestamp;
+exports.validateCompanionRecording = validateCompanionRecording;
+exports.recordLedgerArguments = recordLedgerArguments;
+exports.reconstructLedgerFrames = reconstructLedgerFrames;
+exports.recordLedger = recordLedger;
+/** Reconstruct local instrument-panel observations from immutable ledger history. */
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const ledger_panel_1 = require("./ledger-panel");
+const live_panel_1 = require("./live-panel");
+const USAGE = 'Usage: agentguard-burn record --session <id> [--from <iso>] [--to <iso>] --out <run.jsonl>';
+const MAX_FRAMES = 10000;
+/** Require an explicit timezone and reject dates Date.parse would normalize. */
+function ledgerTimestamp(value) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,3}))?(Z|[+-]\d{2}:\d{2})$/.exec(value);
+    if (!match)
+        throw new Error('Record timestamps must be ISO dates with a timezone and at most millisecond precision.');
+    const year = Number(match[1]), month = Number(match[2]), day = Number(match[3]);
+    const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    const offset = match[8];
+    const at = Date.parse(value);
+    if (month < 1 || month > 12 || day < 1 || day > days[month - 1] || Number(match[4]) > 23
+        || Number(match[5]) > 59 || Number(match[6]) > 59 || !Number.isFinite(at) || at < 0
+        || offset !== 'Z' && (Number(offset.slice(1, 3)) > 23 || Number(offset.slice(4)) > 59)) {
+        throw new Error('Record timestamps must contain a valid date, time and timezone.');
+    }
+    return at;
+}
+/** Compare aliases before writing, including a new file below a symlinked directory. */
+function samePath(left, right) {
+    try {
+        const a = (0, node_fs_1.statSync)(left), b = (0, node_fs_1.statSync)(right);
+        if (a.dev === b.dev && a.ino === b.ino)
+            return true;
+    }
+    catch { /* A fresh output has no inode yet. */ }
+    const physical = (file) => {
+        let path = (0, node_path_1.resolve)(file);
+        const suffix = [];
+        for (;;) {
+            try {
+                return (0, node_path_1.resolve)((0, node_fs_1.realpathSync)(path), ...suffix);
+            }
+            catch {
+                const parent = (0, node_path_1.dirname)(path);
+                if (parent === path)
+                    return (0, node_path_1.resolve)(file);
+                suffix.unshift((0, node_path_1.basename)(path));
+                path = parent;
+            }
+        }
+    };
+    return physical(left) === physical(right);
+}
+function validateCompanionRecording(home, output, recording) {
+    if (samePath(output, recording))
+        throw new Error('Use different paths for --out and --record.');
+    if (['decisions.ndjson', 'receipts.ndjson'].some(name => samePath(recording, (0, node_path_1.join)(home, name)))) {
+        throw new Error('Recording must not append to a source ledger.');
+    }
+}
+function recordLedgerArguments(args) {
+    const fields = {};
+    for (let i = 0; i < args.length; i++) {
+        const flag = args[i];
+        if (!['--session', '--from', '--to', '--out'].includes(flag))
+            throw new Error(USAGE);
+        const key = flag.slice(2), value = args[++i];
+        if (!value || value.startsWith('--') || fields[key] !== undefined)
+            throw new Error(USAGE);
+        fields[key] = value;
+    }
+    if (!fields.session || !fields.out)
+        throw new Error(USAGE);
+    return fields;
+}
+function reconstructLedgerFrames(rows, options) {
+    if (!options.session || /[\x00-\x20\x7f]/.test(options.session))
+        throw new Error('Record requires a session id or an unambiguous prefix.');
+    const selected = (0, ledger_panel_1.resolveLedgerSession)(rows, options.session);
+    if (!selected)
+        throw new Error(`No ledger decisions match session ${options.session}.`);
+    const history = rows.filter(row => row.sessionDigest === selected.sessionDigest);
+    if (!history.length)
+        throw new Error(`No ledger decisions match session ${options.session}.`);
+    const first = history[0], last = history.at(-1);
+    const from = options.from === undefined ? first.at : ledgerTimestamp(options.from);
+    const to = options.to === undefined ? last.at : ledgerTimestamp(options.to);
+    if (from > to)
+        throw new Error('Record --from must be at or before --to.');
+    if ((to - from) / 1000 + 1 > MAX_FRAMES)
+        throw new Error('Recording exceeds the 10,000 frame render limit; select a shorter time range.');
+    const within = history.filter(row => row.at >= from && row.at <= to);
+    if (!within.length)
+        throw new Error('No ledger decisions fall inside the requested time range.');
+    const session = selected.sessionId?.slice(0, 8) ?? selected.sessionDigest.slice(0, 8);
+    const project = (index, at) => {
+        const snapshot = (0, ledger_panel_1.projectLedgerPanel)(history.slice(0, index + 1), selected.sessionDigest, at);
+        return { ...snapshot, session, sessionDigest: selected.sessionDigest, startedAt: first.at, observedAt: at, elapsedMs: Math.max(0, at - first.at), controls: false };
+    };
+    // Seed the hold with prior history without treating an old STOP as a new event.
+    const hold = new live_panel_1.StopHold();
+    let priorIndex = -1;
+    while (priorIndex + 1 < history.length && history[priorIndex + 1].at < from - 2000)
+        priorIndex++;
+    if (priorIndex >= 0)
+        hold.update(project(priorIndex, from - 2000), from - 2000);
+    while (priorIndex + 1 < history.length && history[priorIndex + 1].at < from) {
+        priorIndex++;
+        hold.update(project(priorIndex, history[priorIndex].at), history[priorIndex].at);
+    }
+    const events = [];
+    const decisionTimes = new Set();
+    history.forEach((row, index) => {
+        if (row.at >= from && row.at <= to) {
+            events.push({ at: row.at, index });
+            decisionTimes.add(row.at);
+        }
+    });
+    for (let at = from; at <= to; at += 1000)
+        if (!decisionTimes.has(at))
+            events.push({ at });
+    if ((to - from) % 1000 !== 0 && !decisionTimes.has(to))
+        events.push({ at: to });
+    events.sort((a, b) => a.at - b.at || (a.index ?? -1) - (b.index ?? -1));
+    if (events.length > MAX_FRAMES)
+        throw new Error('Recording exceeds the 10,000 frame render limit; select a shorter time range.');
+    const frames = events.map(event => {
+        if (event.index !== undefined)
+            priorIndex = event.index;
+        else
+            while (priorIndex + 1 < history.length && history[priorIndex + 1].at <= event.at)
+                priorIndex++;
+        const snapshot = hold.update(project(priorIndex, event.at), event.at);
+        return { version: 1, at: new Date(event.at).toISOString(), data: { kind: 'live', snapshot }, viewport: { width: 104, height: 35 } };
+    });
+    const lastStop = history.filter(row => row.at <= to && row.verdict === 'STOP').at(-1);
+    return { frames, session, from, to, decisionCount: within.length, clippedStopHold: Boolean(lastStop && lastStop.at + 2000 > to) };
+}
+function recordLedger(home, options) {
+    if (!options.out || /[\x00-\x1f\x7f]/.test(options.out))
+        throw new Error('Recording output must be a local path without control characters.');
+    const output = (0, node_path_1.resolve)(options.out);
+    if (['decisions.ndjson', 'receipts.ndjson'].some(name => output === (0, node_path_1.resolve)((0, node_path_1.join)(home, name)))) {
+        throw new Error('Recording output must not replace a source ledger.');
+    }
+    const result = reconstructLedgerFrames((0, ledger_panel_1.readPanelLedger)(home), options);
+    const bytes = result.frames.map(frame => JSON.stringify(frame)).join('\n') + '\n';
+    if (Buffer.byteLength(bytes) > 128 * 1024 * 1024)
+        throw new Error('Recording exceeds the 128 MB render limit; select a shorter time range.');
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(output), { recursive: true, mode: 0o700 });
+    try {
+        (0, node_fs_1.writeFileSync)(output, bytes, { flag: 'wx', mode: 0o600 });
+    }
+    catch (error) {
+        if (error.code === 'EEXIST')
+            throw new Error(`Refusing to overwrite existing output: ${output}`);
+        throw error;
+    }
+    return { output, session: result.session, from: new Date(result.from).toISOString(), to: new Date(result.to).toISOString(),
+        frameCount: result.frames.length, decisionCount: result.decisionCount, clippedStopHold: result.clippedStopHold };
+}

package/dist/src/recording.js

@@ -59,7 +59,10 @@ function readRecording(file) {
                 return typeof d.id === 'string' && timestamp(d.at) && typeof d.tool === 'string' && typeof d.reason === 'string'
                     && ['OK', 'WARN', 'STOP'].includes(String(d.verdict)) && (typeof d.blocked === 'boolean' || d.blocked === null);
             };
-            if (!snapshot || typeof snapshot.session !== 'string' || typeof snapshot.note !== 'string'
+            const sessionSwitch = snapshot?.sessionSwitch;
+            if (!snapshot || typeof snapshot.session !== 'string'
+                || !(snapshot.sessionDigest === undefined || typeof snapshot.sessionDigest === 'string' && /^[a-f0-9]{64}$/.test(snapshot.sessionDigest))
+                || !(sessionSwitch === undefined || sessionSwitch && typeof sessionSwitch.from === 'string' && typeof sessionSwitch.to === 'string' && timestamp(sessionSwitch.at)) || typeof snapshot.note !== 'string'
                 || !timestamp(snapshot.observedAt) || !timestamp(snapshot.startedAt)
                 || !(snapshot.windowActiveMinutes === null || count(snapshot.windowActiveMinutes) && snapshot.windowActiveMinutes > 0)
                 || !(snapshot.spawnCeiling === null || count(snapshot.spawnCeiling) && snapshot.spawnCeiling > 0)

package/dist/src/state/spawn-window.d.ts

@@ -1,10 +1,22 @@
+import type { HostCapabilities } from '../events';
 import type { BurnReport, SessionState, Thresholds } from '../types';
 import type { ReserveResult, Transaction } from './reservations';
+/** The exact decision-time measurements retained for local live and replay views. */
+export interface DecisionWindow {
+    activeMinutes: number;
+    windowActiveMinutes: number;
+    spawns: number | null;
+    tokens: number | null;
+    spawnCeiling: number;
+    replayShare: number | null;
+}
+export declare function decisionWindow(state: SessionState, thresholds: Thresholds, proposedSpawn?: boolean, coverage?: Pick<HostCapabilities, 'spawns' | 'usage'>): DecisionWindow;
 /** Evaluate and reserve together. Pending forks must not bypass either window. */
 export declare function evaluateSpawnReservation(tx: Transaction, state: SessionState, thresholds: Thresholds, proposedDepth: number, toolUseId: string, now: number, account?: {
     sessions: SessionState[];
     now: number;
-}): {
+}, coverage?: Pick<HostCapabilities, 'spawns' | 'usage'>): {
     report: BurnReport;
     reservation: ReserveResult;
+    window: DecisionWindow;
 };

package/dist/src/state/spawn-window.js

@@ -1,11 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.decisionWindow = decisionWindow;
 exports.evaluateSpawnReservation = evaluateSpawnReservation;
 const evaluate_1 = require("../detectors/evaluate");
 const defaults_1 = require("../defaults");
 const session_1 = require("./session");
+function decisionWindow(state, thresholds, proposedSpawn = false, coverage) {
+    const windowActiveMinutes = thresholds.spawnRate.windowActiveMinutes;
+    const spawnKnown = !coverage || coverage.spawns !== 'missing';
+    const usageKnown = !coverage || coverage.usage !== 'missing';
+    return {
+        activeMinutes: state.activeMinutes,
+        windowActiveMinutes,
+        spawns: spawnKnown ? (0, session_1.windowSum)(state.spawnsByActiveMinute, state.activeMinutes, windowActiveMinutes) + (proposedSpawn ? 1 : 0) : null,
+        tokens: usageKnown ? (0, session_1.windowSum)(state.tokensByActiveMinute, state.activeMinutes, windowActiveMinutes) : null,
+        spawnCeiling: thresholds.spawnRate.stop,
+        replayShare: usageKnown && state.totalTokens > 0 ? Math.min(1, state.totalCacheRead / state.totalTokens) : null,
+    };
+}
 /** Evaluate and reserve together. Pending forks must not bypass either window. */
-function evaluateSpawnReservation(tx, state, thresholds, proposedDepth, toolUseId, now, account) {
+function evaluateSpawnReservation(tx, state, thresholds, proposedDepth, toolUseId, now, account, coverage) {
     const pending = tx.pendingSpawns(state.sessionId, toolUseId, now);
     const minute = Math.floor(state.activeMinutes);
     const spawns = new Map(state.spawnsByActiveMinute);
@@ -13,13 +27,14 @@ function evaluateSpawnReservation(tx, state, thresholds, proposedDepth, toolUseI
         spawns.set(minute, (spawns.get(minute) ?? 0) + pending);
     const candidateState = { ...state, spawnCount: state.spawnCount + pending, spawnsByActiveMinute: spawns };
     const report = (0, evaluate_1.evaluate)(candidateState, thresholds, proposedDepth, account);
+    const window = decisionWindow(candidateState, thresholds, true, coverage);
     // Receipts retain the lifetime ordinal, while admission uses the active window.
     const effectiveSpawns = state.spawnCount + pending + 1;
     if (report.verdict === 'STOP') {
         // A refused proposal never consumes a reservation. Its detector explains why.
-        return { report, reservation: { allowed: true, effectiveSpawns, pending } };
+        return { report, reservation: { allowed: true, effectiveSpawns, pending }, window };
     }
     const recent = (0, session_1.windowSum)(state.spawnsByActiveMinute, state.activeMinutes, thresholds.fanout.windowActiveMinutes ?? defaults_1.DEFAULT_THRESHOLDS.fanout.windowActiveMinutes);
     const reservation = tx.reserve({ sessionId: state.sessionId, toolUseId, observedSpawns: recent, ceiling: thresholds.fanout.stop, now });
-    return { report, reservation: { ...reservation, effectiveSpawns } };
+    return { report, reservation: { ...reservation, effectiveSpawns }, window };
 }

package/docs/LIVE_PANEL_2026_09.md

@@ -1,55 +1,79 @@
 # 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.
+`agentguard-burn live` reads the local decision and receipt ledgers every half second. It follows the session with the newest decision on each refresh, unless `--session ID` pins a full ID, unique prefix or digest. The header shows the raw ID prefix when available. It does not change admission, write session state, or open a socket.
 
 ```sh
-agentguard-burn live --session e86f091b --record local-run.jsonl
+agentguard-burn live --record local-run.jsonl
+agentguard-burn live --session 0b0c2202 --record pinned-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.
+Use `--once` for one frame. `q` quits and `p` pauses display updates. An observed STOP holds its reason and matching counters for two seconds while intake continues. Switching sessions releases that hold immediately. Recordings carry a `sessionSwitch` object identifying the previous and next sessions and the switch time.
 
-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.
+## One source for both columns
 
-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.
+The hook now records its decision window alongside each ledger decision: active minutes, window length, spawn count including pending reservations and the proposed spawn, tokens in that window, the STOP ceiling, and session cache-read share. Gateway observations respect host coverage; missing usage remains unknown. These are measurements already available during evaluation, not a second evaluation. Receipt payloads and enforcement behavior are unchanged.
 
-## Verification
+Both panel columns use the same session's ledger. Changing the current policy cannot rewrite a recorded window. Elapsed begins at that session's first ledger decision, including history before the displayed range. It does not use the transcript start time. The bar turns amber at 80 percent of the measured ceiling and red at the ceiling.
 
-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.
+Historical ledgers lack exact token-window and cache-read measurements, so those values remain unknown. A spawn-rate finding supplies its observed spawn count. A complete witnessed sequence of proposals can establish earlier counts. Historical configuration is usable only when its canonical hash matches a verified receipt's policy digest. This prevents today's settings from being applied to an unrelated historical policy.
 
-## September 19 evidence
+The right column shows the last eight decisions. When the ledger names the action `spawn` rather than the host tool name, the panel displays `spawn`. At fewer than 80 columns the right column is omitted. Both 104x35 and 80x24 are tested; the compact STOP image uses a native 43-column layout at 390 pixels.
 
-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.
+Colored STOP reports use the same panel without reading files or delaying hooks. Their unrecorded window metrics and elapsed remain unknown. Plain-text hook cards and protocol output retain their previous paths.
 
-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.
+## Reconstruct an event
 
-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.
+```sh
+agentguard-burn record --session 0b0c2202 --from 2026-09-20T20:20:32Z --to 2026-09-20T20:20:52Z --out run.jsonl
+agentguard-burn render run.jsonl --mp4 run.mp4 --gif run.gif
+```
+
+The output must be a new file. Optional bounds default to the session's first and last decisions. Reconstruction writes one frame per decision, including equal timestamps, plus one-second clock frames and explicit range boundaries. Prior rows supply context; future rows never supply earlier measurements. Clock ticks add no decisions or counts. The requested end clips any remaining STOP hold. The video renderer adds its standard one-second final frame; GIF timing is limited to centiseconds.
 
-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.
+## September 20 evidence
 
-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.
+Session `0b0c2202-d0be-4867-97a6-7e050a9b21e0` hashes to `58143098bae620e9ae380915798f2ba88d9342f2de8d3908277461ff7cb0c60d`. The old display's `58143098` therefore referred to this same session. The clip did expose a real defect: persisted transcript state showed zero spawns while pending reservations in the hook ledger advanced from 1 to 16. The previous elapsed clock also began at the older transcript start.
 
-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`.
+The first ledger decision is `2026-09-20T20:20:32.556Z`. The first enforced STOP is `2026-09-20T20:20:49.753Z`, receipt `e7e74842-5779-46e8-b9c2-3bf714e020f6`. Its `spawn_rate` finding records 16 against a threshold of 16. Elapsed at this decision is 17.197 seconds. Two subsequent STOPs at `20:20:50.936Z` and `20:20:51.935Z` remain at 16.
 
-Assets live in `docs/assets/`:
+All 18 receipts in the interval verify, including their chain links. The normalized local policy's hash matches every receipt's policy digest: `7fc75c3841bbe6ee6401bfb57db26e1ce117de1d1dd53095cbb1f7fbc9c5cf6e`. It establishes the 15-active-minute window, WARN at 8 and STOP at 16. No policy or session file was changed. Token-window and replay-share displays remain unknown because those measurements were not recorded in this ledger.
 
-- `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.
+The current showcase replaces the September 19 clip. Original decision timestamps, one-second display ticks and the recorded-run label are preserved. The STOP frame shows 16 spawns, the full red bar and its signed detector reason.
 
-Re-render the shipped recording without reading any private session data:
+Assets under `docs/assets/`:
+
+- `burn-real-stop-sep20.jsonl`: the ledger-derived recording.
+- `burn-real-stop-sep20.mp4` and `burn-real-stop-sep20.gif`: 1920x1080 media.
+- `burn-real-stop-sep20-stop-1920.png` and `burn-real-stop-sep20-stop-390.png`: the first STOP frame.
+- `burn-real-stop-sep20.receipts.ndjson`: the 18 original signed, content-free receipts.
+- `burn-real-stop-sep20.policy.json`: the normalized policy matching their signed digest.
+- `burn-real-stop-sep20.evidence.json`: source hashes, timing, verification and media hashes.
+- `burn-real-stop-sep20.mp4.provenance.json`: renderer version, source digest, frame times and encoding details.
+
+Re-render the committed recording without 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
+agentguard-burn render docs/assets/burn-real-stop-sep20.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.
+## Verification for 0.3.2
+
+Node 22 full suite, including the optional concurrent-hook stress case:
+
+```text
+# STRESS: 240 hook processes; cap=40; admitted=40; denied=200; signed receipts=240; lock failures denied=0; chain valid
+# tests 287
+# pass 287
+# fail 0
+# skipped 0
+```
+
+The initial sandbox run could not bind the local conformance server. The permitted full run passed. Regression coverage includes interleaved sessions, explicit pinning, identity-switch recordings, pending reservations, token-window parity, unknown coverage, historical policy hash matching, recording round trips and the real STOP frame snapshot. Copy checks found no prohibited punctuation or wording in changed text files.
+
+The MP4 is 1920x1080 and 21.000001 seconds; the GIF is 1920x1080 and 21.00 seconds. The requested ledger interval is 20 seconds, followed by the renderer's one-second final frame. Both first-STOP PNGs were visually inspected. The live policy and the source session file remained byte-identical during reconstruction. Version 0.3.2 is prepared locally, with no publication.
+
+MP4 SHA256: `9b31a4ece0dc99e235f3f90b6e07e5ce59d573d094d46ef3b7d9bb56fccd3bfd`.
 
-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.
+GIF SHA256: `d9ca444b696ba84ec33f9e5a143c2a7014c6e7e7f465f45cd54b28d2ba3ea6c4`.

package/docs/assets/burn-real-stop-sep20.evidence.json

@@ -0,0 +1,67 @@
+{
+  "session_id": "0b0c2202-d0be-4867-97a6-7e050a9b21e0",
+  "session_digest": "58143098bae620e9ae380915798f2ba88d9342f2de8d3908277461ff7cb0c60d",
+  "old_display_was_same_session": true,
+  "first_decision": "2026-09-20T20:20:32.556Z",
+  "first_stop": "2026-09-20T20:20:49.753Z",
+  "first_stop_elapsed_ms": 17197,
+  "range": {
+    "from": "2026-09-20T20:20:32Z",
+    "to": "2026-09-20T20:20:52Z"
+  },
+  "source_sha256": {
+    "decisions": "20c23ef927848cf3ca1c738e0f80753ce0290ee9d77f6a9e12d1e6fd6afd8f89",
+    "receipts": "02cbb874d10f8e6d35fd1a96a2c7ac70b91242967accd12eff29b12e7dd74a6a"
+  },
+  "receipt_signatures_verified": 18,
+  "receipt_chain_links_verified": 18,
+  "policy_sha256": "7fc75c3841bbe6ee6401bfb57db26e1ce117de1d1dd53095cbb1f7fbc9c5cf6e",
+  "policy_matches_all_receipts": true,
+  "gate": {
+    "detector": "spawn_rate",
+    "observed": 16,
+    "threshold": 16,
+    "window_active_minutes": 15
+  },
+  "decision_counts": {
+    "OK": 7,
+    "WARN": 8,
+    "STOP": 3
+  },
+  "frame_count": 39,
+  "decision_times": [
+    "2026-09-20T20:20:32.556Z",
+    "2026-09-20T20:20:33.676Z",
+    "2026-09-20T20:20:34.808Z",
+    "2026-09-20T20:20:36.001Z",
+    "2026-09-20T20:20:37.136Z",
+    "2026-09-20T20:20:38.251Z",
+    "2026-09-20T20:20:39.443Z",
+    "2026-09-20T20:20:40.575Z",
+    "2026-09-20T20:20:41.787Z",
+    "2026-09-20T20:20:42.873Z",
+    "2026-09-20T20:20:44.005Z",
+    "2026-09-20T20:20:45.188Z",
+    "2026-09-20T20:20:46.314Z",
+    "2026-09-20T20:20:47.428Z",
+    "2026-09-20T20:20:48.629Z",
+    "2026-09-20T20:20:49.753Z",
+    "2026-09-20T20:20:50.936Z",
+    "2026-09-20T20:20:51.935Z"
+  ],
+  "missing_measurements": [
+    "tokens in window",
+    "session cache-read share"
+  ],
+  "timing": "Original decision timestamps plus one-second clock ticks and explicit range boundaries. STOP holds are display only; the end bound clips them. The renderer adds one second for the final frame. GIF uses centisecond precision.",
+  "output_sha256": {
+    "burn-real-stop-sep20.jsonl": "514152bfe025b12262f288c8fa7c3dc2cbafacd33f5b858f9bad26d981f47038",
+    "burn-real-stop-sep20.mp4": "9b31a4ece0dc99e235f3f90b6e07e5ce59d573d094d46ef3b7d9bb56fccd3bfd",
+    "burn-real-stop-sep20.gif": "d9ca444b696ba84ec33f9e5a143c2a7014c6e7e7f465f45cd54b28d2ba3ea6c4",
+    "burn-real-stop-sep20-stop-1920.png": "7063d9b26d97231db20663a114baf546689165bf782778e3b2f8202262750b4a",
+    "burn-real-stop-sep20-stop-390.png": "1b7eeeb357d9e1e310dc4f5bfb1d6b7babc6232381e4edddc30359aa745555b5",
+    "burn-real-stop-sep20.receipts.ndjson": "bd34a5cc07404d4a3c9023089b133ea01a4d55ee4c7a2558b4b04da966637fda",
+    "burn-real-stop-sep20.policy.json": "9a130d1bf4d8555ba2db0f4f41e24b881774461aaa20a3b6aed1c074e03bbca9",
+    "burn-real-stop-sep20.mp4.provenance.json": "9ef8f9d60b9802cc1f37eb85c87763e44b7577b8cdad3204fff8a8a08bd93f8d"
+  }
+}