@faithfulalabi/agent-lens 0.1.0

package/dist/src/server/start.js

@@ -0,0 +1,150 @@
+import { serve } from '@hono/node-server';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync } from 'node:fs';
+import { readOrCreateToken } from '../shared/index.js';
+import { resolveArchiveRoot, resolveTranscriptRoot } from '../archive/index.js';
+import { createArchiveReader } from '../archive/read.js';
+import { createContentResolver, createContentEnv } from '../content/resolve.js';
+import { createCorpusSweep } from '../corpus/watch.js';
+import { createProjectionEnv } from '../corpus/env.js';
+import { openDb } from '../db/open.js';
+import { readEventArchivePath } from '../db/read.js';
+import { buildApiApp } from './app.js';
+import { clearConfig, writeConfig } from './config.js';
+import { startLiveTick } from './live.js';
+import { createStreamHub } from './stream.js';
+import { createWarmQueue } from './warm.js';
+const DEFAULT_PORT = 4470;
+const MAX_PORT_TRIES = 20;
+const DEFAULT_HOSTNAME = '127.0.0.1';
+const LOOPBACK_HOSTS = new Set(['127.0.0.1', 'localhost', '::1', '[::1]']);
+function resolveDataDir(dataDir) {
+    return dataDir ?? process.env.AGENT_LENS_DIR ?? join(homedir(), '.agent-lens');
+}
+function warnNetworkExposure(host, port) {
+    console.warn([
+        '',
+        '  ############################################################',
+        '  #  WARNING: agent-lens is binding to a non-loopback host.  #',
+        `  #  Listening on ${host}:${port} — reachable over the network.`,
+        '  #  Your traces contain source code and secrets. The token  #',
+        '  #  is the ONLY thing guarding them. Do this on trusted LANs #',
+        '  #  only, and never on a public/untrusted network.          #',
+        '  ############################################################',
+        '',
+    ].join('\n'));
+}
+function bind(fetch, host, port) {
+    return new Promise((resolve, reject) => {
+        const server = serve({ fetch, hostname: host, port }, () => {
+            resolve(server);
+        });
+        server.on('error', reject);
+    });
+}
+export async function startServer(options = {}) {
+    const dataDir = resolveDataDir(options.dataDir);
+    mkdirSync(dataDir, { recursive: true });
+    const host = options.host ?? DEFAULT_HOSTNAME;
+    const token = readOrCreateToken(dataDir);
+    const opened = openDb({ dataDir, port: options.port });
+    const db = opened.db;
+    const reader = createArchiveReader();
+    const roots = {
+        archiveRoot: resolveArchiveRoot(dataDir),
+        transcriptRoot: resolveTranscriptRoot(options.transcriptRoot),
+    };
+    const sweep = createCorpusSweep({
+        db,
+        dataDir,
+        transcriptRoot: options.transcriptRoot,
+        reader,
+        ...(options.sweepIntervalMs !== undefined && { intervalMs: options.sweepIntervalMs }),
+    });
+    const hub = createStreamHub();
+    const warm = createWarmQueue({ db, env: createProjectionEnv(reader, roots), hub });
+    const app = buildApiApp({
+        db,
+        token,
+        host,
+        uiDir: options.uiDir,
+        env: createProjectionEnv(reader, roots),
+        sweep,
+        hub,
+        warm,
+        resolveContent: createContentResolver((id) => readEventArchivePath(db, id)?.archive_path, createContentEnv(reader, [roots.archiveRoot, roots.transcriptRoot])),
+    });
+    const fetch = app.fetch;
+    const explicit = options.port !== undefined;
+    const startPort = explicit ? options.port : DEFAULT_PORT;
+    let server;
+    let boundPort = startPort;
+    for (let attempt = 0; attempt < (explicit ? 1 : MAX_PORT_TRIES); attempt++) {
+        const candidate = startPort + attempt;
+        try {
+            server = await bind(fetch, host, candidate);
+            boundPort = candidate;
+            break;
+        }
+        catch (err) {
+            if (!explicit &&
+                err.code === 'EADDRINUSE' &&
+                attempt < MAX_PORT_TRIES - 1) {
+                continue;
+            }
+            opened.close();
+            throw err;
+        }
+    }
+    if (server === undefined) {
+        opened.close();
+        throw new Error(`unable to bind a port starting at ${startPort}`);
+    }
+    if (startPort === 0) {
+        const address = server.address();
+        if (address !== null && typeof address === 'object') {
+            boundPort = address.port;
+        }
+    }
+    let tick;
+    if (options.sweepIntervalMs !== 0) {
+        sweep.tick();
+        tick = startLiveTick({
+            db,
+            env: createProjectionEnv(reader, roots),
+            sweep,
+            hub,
+            ...(options.sweepIntervalMs !== undefined && { intervalMs: options.sweepIntervalMs }),
+        });
+    }
+    writeConfig(dataDir, {
+        port: boundPort,
+        pid: process.pid,
+        started_at: new Date().toISOString(),
+    });
+    if (!explicit && boundPort !== DEFAULT_PORT) {
+        console.log(`agent-lens: port ${DEFAULT_PORT} in use, listening on ${boundPort}`);
+    }
+    if (!LOOPBACK_HOSTS.has(host)) {
+        warnNetworkExposure(host, boundPort);
+    }
+    return {
+        port: boundPort,
+        close: async () => {
+            tick?.close();
+            warm.close();
+            sweep.close();
+            await hub.drain();
+            return new Promise((resolve) => {
+                if ('closeAllConnections' in server)
+                    server.closeAllConnections();
+                server.close(() => {
+                    opened.close();
+                    clearConfig(dataDir);
+                    resolve();
+                });
+            });
+        },
+    };
+}

package/dist/src/server/static-ui.js

@@ -0,0 +1,97 @@
+import { serveStatic } from '@hono/node-server/serve-static';
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { TOKEN_HEADER } from '../shared/index.js';
+export const BOOTSTRAP_MARKER = '<!--agent-lens-bootstrap-->';
+const IMMUTABLE_CACHE_CONTROL = 'public, max-age=31536000, immutable';
+export function resolveUiDir(fromDir) {
+    const start = fromDir ?? dirname(fileURLToPath(import.meta.url));
+    let dir = start;
+    for (;;) {
+        if (existsSync(join(dir, 'package.json')))
+            return join(dir, 'ui', 'dist');
+        const parent = dirname(dir);
+        if (parent === dir) {
+            throw new Error(`agent-lens: no package.json above ${start}; cannot locate ui/dist`);
+        }
+        dir = parent;
+    }
+}
+function jsLiteral(value) {
+    return JSON.stringify(value).replace(/</g, '\\u003C');
+}
+function hasBootstrapMarker(html) {
+    return html.includes(BOOTSTRAP_MARKER);
+}
+export function injectToken(html, token) {
+    if (!hasBootstrapMarker(html)) {
+        throw new Error(`agent-lens: ${BOOTSTRAP_MARKER} not found in index.html — the UI build is missing or stale`);
+    }
+    const script = `<script>window.__AGENT_LENS__=Object.freeze(` +
+        `{token:${jsLiteral(token)},tokenHeader:${jsLiteral(TOKEN_HEADER)}})</script>`;
+    return html.replace(BOOTSTRAP_MARKER, () => script);
+}
+export function renderNotBuilt() {
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<meta name="color-scheme" content="dark" />
+<title>agent-lens — UI not built</title>
+<style>
+  body { background: #0b0b0e; color: #e6e6ea; font: 15px/1.6 ui-sans-serif, system-ui, sans-serif;
+         margin: 0; display: grid; place-items: center; min-height: 100vh; }
+  main { max-width: 34rem; padding: 2rem; }
+  h1 { font-size: 1.25rem; margin: 0 0 .75rem; }
+  code { background: #1a1a20; border-radius: 4px; padding: .15rem .4rem;
+         font-family: ui-monospace, SFMono-Regular, monospace; }
+  p { margin: 0 0 .75rem; color: #a1a1ad; }
+</style>
+</head>
+<body>
+<main>
+  <h1>The agent-lens UI is not built</h1>
+  <p>The UI bundle is missing or stale. Build it, then reload this page:</p>
+  <p><code>npm run build</code></p>
+  <p>The collector itself is running — the API under <code>/api/</code> is
+     serving normally, so nothing that was captured has been lost.</p>
+</main>
+</body>
+</html>`;
+}
+async function readIndexHtml(uiDir) {
+    let html;
+    try {
+        html = await readFile(join(uiDir, 'index.html'), 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return undefined;
+        throw err;
+    }
+    return hasBootstrapMarker(html) ? html : undefined;
+}
+export function makeServeIndex(options) {
+    return async (c) => {
+        const html = await readIndexHtml(options.uiDir ?? resolveUiDir());
+        c.header('Cache-Control', 'no-store');
+        return c.html(html === undefined ? renderNotBuilt() : injectToken(html, options.token));
+    };
+}
+export function registerUi(app, options) {
+    app.use('/assets/*', async (c, next) => {
+        await next();
+        if (c.res.status === 200)
+            c.header('Cache-Control', IMMUTABLE_CACHE_CONTROL);
+    });
+    let assets;
+    app.use('/assets/*', (c, next) => {
+        assets ??= serveStatic({ root: options.uiDir ?? resolveUiDir() });
+        return assets(c, next);
+    });
+    app.all('/assets/*', (c) => c.text('not found', 404));
+    app.get('*', makeServeIndex(options));
+}

package/dist/src/server/stream.js

@@ -0,0 +1,50 @@
+export const STREAM_EVENTS = [
+    'session_changed',
+    'session_indexed',
+    'warm_progress',
+    'heartbeat',
+];
+export const HEARTBEAT_MS = 15_000;
+export function createStreamHub(options = {}) {
+    const heartbeatMs = options.heartbeatMs ?? HEARTBEAT_MS;
+    const clients = new Map();
+    const release = (stream) => {
+        const client = clients.get(stream);
+        if (client === undefined)
+            return;
+        clients.delete(stream);
+        client.unpark();
+    };
+    const attach = (stream) => new Promise((unpark) => {
+        clients.set(stream, { stream, unpark });
+        stream.onAbort(() => release(stream));
+    });
+    const fanOut = async (event, data, id) => {
+        const message = { event, data, ...(id !== undefined && { id }) };
+        await Promise.all([...clients.values()].map(async ({ stream }) => {
+            if (stream.aborted || stream.closed) {
+                release(stream);
+                return;
+            }
+            await stream.writeSSE(message);
+        }));
+    };
+    const beat = () => fanOut('heartbeat', '');
+    const timer = setInterval(() => void beat(), heartbeatMs);
+    timer.unref?.();
+    return {
+        attach,
+        publish: (event, data, id) => fanOut(event, JSON.stringify(data), id),
+        beat,
+        size: () => clients.size,
+        drain: async () => {
+            clearInterval(timer);
+            const attached = [...clients.values()];
+            clients.clear();
+            await Promise.all(attached.map(async ({ stream, unpark }) => {
+                unpark();
+                await stream.close();
+            }));
+        },
+    };
+}

package/dist/src/server/warm.js

@@ -0,0 +1,48 @@
+import { ensureProjectedFold } from '../db/freshness.js';
+import { readWarmableIds } from '../db/read.js';
+const yieldToLoop = () => new Promise((resolve) => setImmediate(resolve));
+export function createWarmQueue(options) {
+    const { db, env, hub } = options;
+    const yieldTo = options.yieldTo ?? yieldToLoop;
+    let inFlight = false;
+    let closed = false;
+    const drain = async (ids) => {
+        const total = ids.length;
+        let done = 0;
+        for (const id of ids) {
+            await yieldTo();
+            if (closed)
+                return;
+            try {
+                ensureProjectedFold(db, id, env);
+            }
+            catch (error) {
+                console.error(error);
+            }
+            done += 1;
+            const frame = { done, total };
+            await hub.publish('warm_progress', frame);
+        }
+    };
+    return {
+        start: () => {
+            if (closed)
+                return 0;
+            const ids = readWarmableIds(db);
+            if (inFlight)
+                return ids.length;
+            if (ids.length === 0)
+                return 0;
+            inFlight = true;
+            void drain(ids)
+                .catch((error) => console.error(error))
+                .finally(() => {
+                inFlight = false;
+            });
+            return ids.length;
+        },
+        close: () => {
+            closed = true;
+        },
+    };
+}

package/dist/src/shared/api.js

@@ -0,0 +1 @@
+export {};

package/dist/src/shared/entities.js

@@ -0,0 +1 @@
+export {};

package/dist/src/shared/index.js

@@ -0,0 +1,2 @@
+export { estimateCost } from './pricing.js';
+export { readOrCreateToken, readToken, TOKEN_HEADER } from './token.js';

package/dist/src/shared/pricing.js

@@ -0,0 +1,68 @@
+import { createHash } from 'node:crypto';
+function canonicalJson(value) {
+    return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+    if (Array.isArray(value))
+        return value.map(sortKeys);
+    if (value !== null && typeof value === 'object') {
+        const source = value;
+        const sorted = {};
+        for (const key of Object.keys(source).sort())
+            sorted[key] = sortKeys(source[key]);
+        return sorted;
+    }
+    return value;
+}
+export const PRICING_TABLE = Object.freeze({
+    'claude-fable-5-1': { input: 10, output: 50, cache_read: 0.25, cache_write: 12.5 },
+    'claude-mythos-5-1': { input: 10, output: 50, cache_read: 0.25, cache_write: 12.5 },
+    'claude-fable-5': { input: 10, output: 50, cache_read: 1, cache_write: 12.5 },
+    'claude-mythos-5': { input: 10, output: 50, cache_read: 1, cache_write: 12.5 },
+    'claude-opus-5-5': { input: 4, output: 20, cache_read: 0.2, cache_write: 5 },
+    'claude-opus-5': { input: 5, output: 25, cache_read: 0.5, cache_write: 6.25 },
+    'claude-opus-4-8': { input: 5, output: 25, cache_read: 0.5, cache_write: 6.25 },
+    'claude-opus-4-7': { input: 5, output: 25, cache_read: 0.5, cache_write: 6.25 },
+    'claude-opus-4-6': { input: 5, output: 25, cache_read: 0.5, cache_write: 6.25 },
+    'claude-opus-4-5': { input: 5, output: 25, cache_read: 0.5, cache_write: 6.25 },
+    'claude-opus-4-1': { input: 15, output: 75, cache_read: 1.5, cache_write: 18.75 },
+    'claude-opus-4': { input: 15, output: 75, cache_read: 1.5, cache_write: 18.75 },
+    'claude-sonnet-5': { input: 2, output: 10, cache_read: 0.2, cache_write: 2.5 },
+    'claude-sonnet-4-6': { input: 3, output: 15, cache_read: 0.3, cache_write: 3.75 },
+    'claude-sonnet-4-5': { input: 3, output: 15, cache_read: 0.3, cache_write: 3.75 },
+    'claude-sonnet-4': { input: 3, output: 15, cache_read: 0.3, cache_write: 3.75 },
+    'claude-haiku-4-5': { input: 1, output: 5, cache_read: 0.1, cache_write: 1.25 },
+    'claude-3-5-haiku': { input: 0.8, output: 4, cache_read: 0.08, cache_write: 1 },
+});
+export const PRICING_TABLE_DATE = '2026-09-22';
+export const PRICING_VERSION = `${PRICING_TABLE_DATE}+${createHash('sha256')
+    .update(canonicalJson(PRICING_TABLE), 'utf8')
+    .digest('hex')
+    .slice(0, 8)}`;
+const BUILD_SUFFIX = /-\d{8}$/;
+const CONTEXT_TAG = /\[[^\]]*\]$/;
+const VENDOR_PREFIX = /^(?:[a-z]{2,4}\.)?anthropic\./;
+export function normalizeModelKey(raw) {
+    const model = raw.replace(CONTEXT_TAG, '');
+    const withoutVendor = model.replace(VENDOR_PREFIX, '');
+    const candidates = [
+        model,
+        model.replace(BUILD_SUFFIX, ''),
+        withoutVendor,
+        withoutVendor.replace(BUILD_SUFFIX, ''),
+    ];
+    return candidates.find((key) => key !== '' && key in PRICING_TABLE);
+}
+export function estimateCost(model, usage) {
+    if (model === undefined || model === '')
+        return null;
+    const key = normalizeModelKey(model);
+    if (key === undefined)
+        return null;
+    const price = PRICING_TABLE[key];
+    const millionths = (usage.tokens_in ?? 0) * price.input +
+        (usage.tokens_out ?? 0) * price.output +
+        (usage.cache_read ?? 0) * price.cache_read +
+        (usage.cache_write ?? 0) * price.cache_write;
+    return millionths / 1_000_000;
+}

package/dist/src/shared/token.js

@@ -0,0 +1,39 @@
+import { randomBytes } from 'node:crypto';
+import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export const TOKEN_HEADER = 'x-agentlens-token';
+const TOKEN_FILE = 'token';
+function resolveDir(dir) {
+    return dir ?? process.env.AGENT_LENS_DIR ?? join(homedir(), '.agent-lens');
+}
+function generateToken() {
+    return randomBytes(32).toString('base64url');
+}
+export function readToken(dir) {
+    const tokenPath = join(resolveDir(dir), TOKEN_FILE);
+    try {
+        return readFileSync(tokenPath, 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return null;
+        }
+        throw err;
+    }
+}
+export function readOrCreateToken(dir) {
+    const existing = readToken(dir);
+    if (existing !== null) {
+        return existing;
+    }
+    const targetDir = resolveDir(dir);
+    mkdirSync(targetDir, { recursive: true });
+    const token = generateToken();
+    const tokenPath = join(targetDir, TOKEN_FILE);
+    const tempPath = join(targetDir, `${TOKEN_FILE}.tmp.${process.pid}`);
+    writeFileSync(tempPath, token, { mode: 0o600 });
+    chmodSync(tempPath, 0o600);
+    renameSync(tempPath, tokenPath);
+    return token;
+}

package/dist/src/transcript/accessors.js

@@ -0,0 +1,28 @@
+export function str(value, fallback) {
+    return typeof value === 'string' ? value : fallback;
+}
+export function num(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+export function arr(value, fallback) {
+    try {
+        return Array.isArray(value) ? value : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+export function obj(value, fallback) {
+    try {
+        if (value === null || typeof value !== 'object' || Array.isArray(value))
+            return fallback;
+        return value;
+    }
+    catch {
+        return fallback;
+    }
+}
+const ISO_8601 = /^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d{1,9})?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/;
+export function isoTs(value, fallback) {
+    return typeof value === 'string' && ISO_8601.test(value) ? value : fallback;
+}

package/dist/src/transcript/agents.js

@@ -0,0 +1,44 @@
+import { num, obj, str } from './accessors.js';
+const PERSISTED_MARKER = '<persisted-output>';
+const ASYNC_LAUNCH_MARKER = 'Async agent launched successfully.';
+const NOTIFICATION_TAG = '<task-notification>';
+const MARKER_AGENT_ID = /^agentId: (\S+)/m;
+function tag(name) {
+    return new RegExp(`<${name}>([\\s\\S]*?)</${name}>`);
+}
+const TOOL_CALL_ID = tag('tool-use-id');
+const STATUS = tag('status');
+const RESULT = tag('result');
+export function asyncAgentLaunch(line, text) {
+    const structured = obj(line.raw.toolUseResult, undefined);
+    if (structured?.isAsync === true) {
+        return { agentId: str(structured.agentId, undefined) };
+    }
+    if (!text.startsWith(ASYNC_LAUNCH_MARKER))
+        return undefined;
+    return { agentId: MARKER_AGENT_ID.exec(text)?.[1] };
+}
+export function taskNotification(text) {
+    if (!text.startsWith(NOTIFICATION_TAG))
+        return undefined;
+    return {
+        toolCallId: TOOL_CALL_ID.exec(text)?.[1],
+        status: STATUS.exec(text)?.[1],
+        result: RESULT.exec(text)?.[1],
+    };
+}
+export function parseAgentMeta(json) {
+    const meta = obj(json, undefined);
+    if (meta === undefined)
+        return undefined;
+    return {
+        agentType: str(meta.agentType, undefined),
+        description: str(meta.description, undefined),
+        toolUseId: str(meta.toolUseId, undefined),
+        spawnDepth: num(meta.spawnDepth, undefined),
+        parentAgentId: str(meta.parentAgentId, undefined),
+    };
+}
+export function claimsPersistedOutput(text) {
+    return text.startsWith(PERSISTED_MARKER);
+}

package/dist/src/transcript/blocks.js

@@ -0,0 +1,75 @@
+import { arr, obj, str } from './accessors.js';
+export const THINKING_ELIDED_MARKER = 'reasoning not recorded (signature only)';
+const EMPTY_RECORD = Object.freeze({});
+const NO_BLOCKS = Object.freeze([]);
+const BYTES_PER_KB = 1000;
+const BYTES_PER_MB = 1_000_000;
+export function normalizeContent(content) {
+    if (typeof content === 'string')
+        return [{ type: 'text', text: content }];
+    return arr(content, NO_BLOCKS);
+}
+function toolReferenceBlock(raw) {
+    return { kind: 'tool_reference', name: str(raw.tool_name, '') };
+}
+function imagePlaceholder(mediaType, byteLength) {
+    const size = byteLength < BYTES_PER_MB
+        ? `${(byteLength / BYTES_PER_KB).toFixed(1)} KB`
+        : `${(byteLength / BYTES_PER_MB).toFixed(1)} MB`;
+    return `[image ${mediaType}, ${size}]`;
+}
+function imageBlock(raw) {
+    const source = obj(raw.source, EMPTY_RECORD);
+    const media_type = str(source.media_type, '');
+    const byte_length = (str(source.data, '').length * 3) / 4;
+    return {
+        kind: 'image',
+        media_type,
+        byte_length,
+        placeholder: imagePlaceholder(media_type, byte_length),
+    };
+}
+export function classifyBlock(raw, position) {
+    const block = obj(raw, EMPTY_RECORD);
+    const type = str(block.type, '');
+    switch (type) {
+        case 'text':
+            return { kind: 'text', text: str(block.text, '') };
+        case 'thinking': {
+            const text = str(block.thinking, '');
+            return text === ''
+                ? { kind: 'thinking_elided', text: THINKING_ELIDED_MARKER }
+                : { kind: 'thinking', text };
+        }
+        case 'tool_use':
+            return {
+                kind: 'tool_use',
+                id: str(block.id, ''),
+                name: str(block.name, ''),
+                input: obj(block.input, undefined),
+            };
+        case 'tool_result':
+            if (position === 'top') {
+                return {
+                    kind: 'tool_result',
+                    tool_call_id: str(block.tool_use_id, ''),
+                    is_error: block.is_error === true,
+                    children: normalizeContent(block.content).map((child) => classifyBlock(child, 'in_tool_result')),
+                };
+            }
+            break;
+        case 'image':
+            return imageBlock(block);
+        case 'tool_reference':
+            if (position === 'in_tool_result')
+                return toolReferenceBlock(block);
+            break;
+    }
+    return { kind: 'unknown_block', raw_type: type };
+}
+export function classifyContent(content) {
+    return normalizeContent(content).map((block) => classifyBlock(block, 'top'));
+}
+export function contentBlocks(line) {
+    return classifyContent(obj(line.raw.message, undefined)?.content);
+}

package/dist/src/transcript/drift.js

@@ -0,0 +1,42 @@
+function bucket(counts) {
+    if (counts.size === 0)
+        return undefined;
+    return Object.fromEntries([...counts.entries()].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));
+}
+function bump(counts, key) {
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+}
+export class DriftCounter {
+    lineTypes = new Map();
+    fields = new Map();
+    blockTypes = new Map();
+    unjoinedToolUses = 0;
+    sidecarAgentIdMismatches = 0;
+    noteLine(line, knownFields) {
+        for (const name of Object.keys(line)) {
+            if (!knownFields.has(name))
+                bump(this.fields, name);
+        }
+    }
+    noteUnknownType(rawType) {
+        bump(this.lineTypes, rawType);
+    }
+    noteUnknownBlock(rawType) {
+        bump(this.blockTypes, rawType);
+    }
+    noteUnjoinedToolUse() {
+        this.unjoinedToolUses += 1;
+    }
+    noteSidecarMismatch() {
+        this.sidecarAgentIdMismatches += 1;
+    }
+    serialize() {
+        return JSON.stringify({
+            sidecar_agent_id_mismatch: this.sidecarAgentIdMismatches === 0 ? undefined : this.sidecarAgentIdMismatches,
+            unjoined_tool_uses: this.unjoinedToolUses === 0 ? undefined : this.unjoinedToolUses,
+            unknown_block_types: bucket(this.blockTypes),
+            unknown_line_types: bucket(this.lineTypes),
+            unknown_top_level_fields: bucket(this.fields),
+        });
+    }
+}