sidekick-shared 0.27.6 → 0.28.0

package/dist/esm/types/observedSessionV1.js

@@ -0,0 +1,257 @@
+import { projectSessionTranscript } from '../transcript';
+import { classifySessionActivity, refreshSessionActivityState, } from '../parsers/sessionActivityDetector';
+import { computeSessionFileStats, providerContextSizeFn } from '../sessionStats';
+import { fingerprintString, sessionFingerprintParts } from '../sessionFingerprint';
+function evidence(provider, sessionId, sourcePath, event, eventIndex) {
+    return [
+        {
+            schemaVersion: 1,
+            provider,
+            sessionId,
+            sourcePath,
+            eventIndex,
+            eventId: event?.message?.id,
+            timestamp: event?.timestamp,
+        },
+    ];
+}
+function observed(value, provenance, confidence, refs) {
+    return { value, provenance, confidence, evidence: refs };
+}
+export function derivePendingUserRequestV1(provider, sessionId, sourcePath, events) {
+    for (let index = events.length - 1; index >= 0; index--) {
+        const event = events[index];
+        // A user/tool-result event after a request means the human has responded.
+        if (event.type === 'user')
+            return null;
+        const request = waitingToolRequest(event);
+        if (request) {
+            const refs = evidence(provider, sessionId, sourcePath, event, index);
+            return {
+                schemaVersion: 1,
+                id: `${provider}:${sessionId}:${request.id ?? event.message?.id ?? index}`,
+                provider,
+                sessionId,
+                kind: observed(request.kind, 'inferred', request.kind === 'question' ? 0.95 : 0.9, refs),
+                requestedAt: observed(event.timestamp, 'reported', 1, refs),
+                prompt: observed(request.prompt, request.prompt ? 'reported' : 'inferred', request.prompt ? 0.95 : 0.4, refs),
+            };
+        }
+        // A later assistant turn proves any older request was already resolved.
+        if (event.type === 'assistant' || event.type === 'tool_use')
+            return null;
+    }
+    return null;
+}
+function waitingToolRequest(event) {
+    const calls = [];
+    const message = event.message;
+    if (event.type === 'tool_use') {
+        calls.push({ id: message?.id, name: event.tool?.name, input: event.tool?.input });
+    }
+    if (Array.isArray(message?.content)) {
+        for (const block of message.content) {
+            if (!block || typeof block !== 'object')
+                continue;
+            const value = block;
+            if (value.type !== 'tool_use')
+                continue;
+            calls.push({
+                id: typeof value.id === 'string' ? value.id : undefined,
+                name: typeof value.name === 'string' ? value.name : undefined,
+                input: value.input,
+            });
+        }
+    }
+    for (let index = calls.length - 1; index >= 0; index--) {
+        const call = calls[index];
+        if (call.name !== 'AskUserQuestion' && call.name !== 'ExitPlanMode')
+            continue;
+        return {
+            id: call.id,
+            kind: call.name === 'AskUserQuestion' ? 'question' : 'tool_approval',
+            prompt: waitingToolPrompt(call.input, call.name),
+        };
+    }
+    return null;
+}
+function waitingToolPrompt(input, toolName) {
+    if (!input || typeof input !== 'object') {
+        return toolName === 'ExitPlanMode' ? 'Approve the proposed plan?' : null;
+    }
+    const record = input;
+    if (typeof record.question === 'string')
+        return record.question;
+    if (typeof record.prompt === 'string')
+        return record.prompt;
+    if (Array.isArray(record.questions)) {
+        const questions = record.questions
+            .map((question) => question && typeof question === 'object' && 'question' in question
+            ? String(question.question ?? '')
+            : '')
+            .filter(Boolean);
+        if (questions.length > 0)
+            return questions.join('\n');
+    }
+    if (toolName === 'ExitPlanMode')
+        return 'Approve the proposed plan?';
+    return null;
+}
+function providerCapabilities(provider, observationOnly) {
+    const refs = [];
+    const known = (value) => observed(value, 'inferred', 1, refs);
+    return {
+        schemaVersion: 1,
+        provider,
+        resume: known(!observationOnly),
+        forkLineage: known(provider !== 'opencode'),
+        quotaSource: known(provider === 'claude-code' ? 'api' : provider === 'codex' ? 'mixed' : 'none'),
+        assetExtraction: known(true),
+    };
+}
+/**
+ * Detector reason behind each observed session's activity, kept off the
+ * versioned V1 shape so cache refreshes can tell a grace-period "active" from
+ * a genuinely ongoing one.
+ */
+const activityReasons = new WeakMap();
+/** The activity detector's reason for a session produced by this adapter, if known. */
+export function getObservedActivityReason(session) {
+    return activityReasons.get(session);
+}
+export function createProviderSessionAdapterV1(sessionProvider, options = {}) {
+    const pollIntervalMs = options.pollIntervalMs ?? 2_000;
+    const adapter = {
+        schemaVersion: 1,
+        provider: sessionProvider.id,
+        capabilities: providerCapabilities(sessionProvider.id, options.observationOnly === true),
+        async discover(cwd) {
+            return Promise.all(sessionProvider.findAllSessions(cwd).map((sessionPath) => adapter.read(sessionPath, cwd)));
+        },
+        async read(sessionPath, cwd = '') {
+            // One reader pass feeds stats, transcript, activity, and the pending
+            // request; the reader is flushed so a trailing partial line is included.
+            const sessionId = sessionProvider.getSessionId(sessionPath);
+            const reader = sessionProvider.createReader(sessionPath);
+            const events = reader.readAll();
+            reader.flush();
+            const stats = computeSessionFileStats(events, {
+                providerId: sessionProvider.id,
+                sessionId,
+                filePath: sessionPath,
+                label: '',
+                computeContextSize: providerContextSizeFn(sessionProvider),
+            });
+            const transcript = projectSessionTranscript(events, {
+                provider: sessionProvider.id,
+                sessionId,
+                sourcePath: sessionPath,
+            });
+            const refs = evidence(sessionProvider.id, sessionId, sessionPath);
+            const model = Object.entries(stats.modelUsage).sort((left, right) => right[1].calls - left[1].calls)[0]?.[0] ?? null;
+            const parts = sessionFingerprintParts(sessionProvider, sessionPath);
+            const activityResult = classifySessionActivity({ events, mtimeMs: parts?.mtimeMs ?? null });
+            const activity = activityResult.state === 'ongoing'
+                ? 'active'
+                : activityResult.state === 'stale'
+                    ? 'idle'
+                    : 'ended';
+            const allCostsReported = transcript.usage.costs.length > 0 &&
+                transcript.usage.costs.every((cost) => cost.source === 'provider-reported');
+            const observedAt = new Date().toISOString();
+            const session = {
+                schemaVersion: 1,
+                identity: {
+                    provider: sessionProvider.id,
+                    sessionId,
+                    sourcePath: sessionPath,
+                },
+                cwd: observed(cwd, 'inferred', cwd ? 0.95 : 0.4, refs),
+                model: observed(model, model ? 'reported' : 'inferred', model ? 1 : 0.2, refs),
+                activity: observed(activity, 'inferred', 0.85, refs),
+                usage: {
+                    inputTokens: observed(stats.tokens.input, 'reported', 1, refs),
+                    outputTokens: observed(stats.tokens.output, 'reported', 1, refs),
+                    cacheReadTokens: observed(stats.tokens.cacheRead, 'reported', 1, refs),
+                    cacheWriteTokens: observed(stats.tokens.cacheWrite, 'reported', 1, refs),
+                    normalized: observed(transcript.usage.totals, 'reported', 1, refs),
+                    costUsd: observed(transcript.usage.totalCostUsd, allCostsReported
+                        ? 'reported'
+                        : transcript.usage.totalCostUsd === null
+                            ? 'inferred'
+                            : 'estimated', allCostsReported ? 1 : transcript.usage.totalCostUsd === null ? 0.5 : 0.9, refs),
+                },
+                pendingUserRequest: derivePendingUserRequestV1(sessionProvider.id, sessionId, sessionPath, events),
+                contentObservedAt: observedAt,
+                observedAt,
+            };
+            activityReasons.set(session, activityResult.reason);
+            return session;
+        },
+        watch(sessionPath, listener, cwd) {
+            let disposed = false;
+            let lastSignature = '';
+            let lastFingerprint = null;
+            let lastSession = null;
+            const emitIfChanged = (session) => {
+                const signature = JSON.stringify({
+                    activity: session.activity,
+                    model: session.model,
+                    usage: session.usage,
+                    pendingUserRequest: session.pendingUserRequest,
+                });
+                if (signature !== lastSignature) {
+                    lastSignature = signature;
+                    listener(session);
+                }
+            };
+            const update = async () => {
+                if (disposed)
+                    return;
+                try {
+                    const parts = sessionFingerprintParts(sessionProvider, sessionPath);
+                    const fingerprint = parts ? fingerprintString(parts) : null;
+                    if (lastSession && parts && fingerprint === lastFingerprint) {
+                        // Unchanged content: only the activity can drift with time, so
+                        // refresh it from the cached classification instead of re-reading.
+                        const previousReason = activityReasons.get(lastSession);
+                        const refreshed = refreshSessionActivityState(lastSession.activity.value, parts.mtimeMs, Date.now(), previousReason);
+                        if (refreshed !== lastSession.activity.value) {
+                            const session = {
+                                ...lastSession,
+                                activity: { ...lastSession.activity, value: refreshed },
+                                observedAt: new Date().toISOString(),
+                            };
+                            activityReasons.set(session, refreshed === 'idle'
+                                ? 'mtime-stale'
+                                : previousReason === 'grace-period'
+                                    ? 'ending-event'
+                                    : 'no-activity-signal');
+                            lastSession = session;
+                            emitIfChanged(session);
+                        }
+                        return;
+                    }
+                    const session = await adapter.read(sessionPath, cwd);
+                    lastFingerprint = fingerprint;
+                    lastSession = session;
+                    emitIfChanged(session);
+                }
+                catch {
+                    // Observed sources can disappear between polling iterations.
+                }
+            };
+            void update();
+            const timer = setInterval(update, pollIntervalMs);
+            timer.unref?.();
+            return {
+                dispose: () => {
+                    disposed = true;
+                    clearInterval(timer);
+                },
+            };
+        },
+        dispose: () => sessionProvider.dispose(),
+    };
+    return adapter;
+}

package/dist/esm/types/opencode.js

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview Type definitions for OpenCode session storage format.
+ *
+ * OpenCode stores data as individual JSON files in ~/.local/share/opencode/storage/:
+ * - Sessions: storage/session/{projectID}/{sessionID}.json
+ * - Messages: storage/message/{sessionID}/{messageID}.json
+ * - Parts: storage/part/{messageID}/{partID}.json
+ * - Projects: storage/project/{projectID}.json
+ *
+ * @module types/opencode
+ */
+export {};

package/dist/esm/types/plan.js

@@ -0,0 +1,7 @@
+/**
+ * On-disk schema types for plan persistence.
+ * Plans are extracted from agent sessions and persisted for analytics and history.
+ */
+export const PLAN_SCHEMA_VERSION = 1;
+/** Maximum number of plans to keep per project */
+export const MAX_PLANS_PER_PROJECT = 50;

package/dist/esm/types/sessionEvent.js

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview Canonical session event types shared across VS Code extension and CLI.
+ *
+ * These types define the rich event model used for parsing and monitoring
+ * Claude Code, OpenCode, and Codex CLI sessions. SessionEvent is the canonical
+ * type; ClaudeSessionEvent is a backward-compatible alias.
+ *
+ * @module types/sessionEvent
+ */
+export {};

package/dist/esm/types/taskPersistence.js

@@ -0,0 +1,12 @@
+/**
+ * On-disk schema types for cross-session task persistence.
+ * Canonical source: sidekick-vscode/src/types/taskPersistence.ts + claudeSession.ts (TaskStatus)
+ */
+export const TASK_PERSISTENCE_SCHEMA_VERSION = 1;
+export function normalizeTaskStatus(status) {
+    if (status === 'in_progress')
+        return 'in_progress';
+    if (status === 'completed')
+        return 'completed';
+    return 'pending';
+}

package/dist/esm/usage/billingBlocks.js

@@ -0,0 +1,148 @@
+/**
+ * Five-hour billing blocks computed from usage events.
+ *
+ * Mirrors the ccusage convention: a block opens at the first usage event
+ * (aligned down to the UTC hour), lasts five hours, and an event that lands
+ * after the block's end or more than five hours after the previous event opens
+ * a new block. The active block also reports a burn rate and an end-of-block
+ * projection. Browser-safe: no Node imports.
+ *
+ * @module usage/billingBlocks
+ */
+import { classifyCostProvenance } from '../aggregation/costProvenance';
+import { BurnRateCalculator } from '../statusline/BurnRateCalculator';
+import { summarizeTokens } from '../tokenSummary';
+/** Length of one billing block. */
+export const BILLING_BLOCK_DURATION_MS = 5 * 3_600_000;
+function toMs(value) {
+    if (value instanceof Date)
+        return value.getTime();
+    if (typeof value === 'number')
+        return value;
+    return Date.parse(value);
+}
+function normalizeInput(event) {
+    const timestamp = toMs(event.timestamp);
+    if (!Number.isFinite(timestamp))
+        return null;
+    const costUsd = typeof event.costUsd === 'number' && Number.isFinite(event.costUsd) ? event.costUsd : null;
+    return {
+        timestamp,
+        tokens: event.tokens,
+        costUsd,
+        costProvenance: costUsd === null ? 'unpriced' : (event.costProvenance ?? 'model-catalog'),
+        model: event.model ?? 'unknown',
+    };
+}
+function floorToUtcHour(ms) {
+    return ms - (ms % 3_600_000);
+}
+function buildBlock(events, start, durationMs, nowMs) {
+    const end = start + durationMs;
+    const first = events[0].timestamp;
+    const last = events[events.length - 1].timestamp;
+    const isActive = nowMs >= start && nowMs < end && nowMs - last < durationMs;
+    const tokens = { inputTokens: 0, outputTokens: 0, cacheWriteTokens: 0, cacheReadTokens: 0 };
+    let total = 0;
+    let costUsd = 0;
+    let reportedCalls = 0;
+    let estimatedCalls = 0;
+    let unpricedCalls = 0;
+    const models = {};
+    const burn = new BurnRateCalculator(durationMs / 60_000);
+    for (const event of events) {
+        const summary = summarizeTokens(event.tokens);
+        tokens.inputTokens += summary.input;
+        tokens.outputTokens += summary.output;
+        tokens.cacheWriteTokens += summary.cacheWrite;
+        tokens.cacheReadTokens += summary.cacheRead;
+        total += summary.total;
+        burn.addEvent(summary.total, new Date(event.timestamp));
+        const model = models[event.model] ?? { calls: 0, tokens: 0, costUsd: 0 };
+        model.calls += 1;
+        model.tokens += summary.total;
+        if (event.costUsd !== null) {
+            costUsd += event.costUsd;
+            model.costUsd += event.costUsd;
+            if (event.costProvenance === 'provider-reported')
+                reportedCalls += 1;
+            else
+                estimatedCalls += 1;
+        }
+        else {
+            unpricedCalls += 1;
+        }
+        models[event.model] = model;
+    }
+    const rateAt = isActive ? nowMs : last;
+    const elapsedMs = Math.max(0, rateAt - first);
+    const burnRatePerMinute = burn.calculateBurnRate(new Date(rateAt));
+    const remainingMs = isActive ? Math.max(0, end - nowMs) : 0;
+    const projectedTokens = isActive
+        ? Math.round(total + burnRatePerMinute * (remainingMs / 60_000))
+        : total;
+    const costPerToken = total > 0 ? costUsd / total : 0;
+    const projectedCostUsd = isActive ? costUsd + costPerToken * (projectedTokens - total) : costUsd;
+    const startIso = new Date(start).toISOString();
+    return {
+        id: startIso,
+        start: startIso,
+        end: new Date(end).toISOString(),
+        firstEvent: new Date(first).toISOString(),
+        lastEvent: new Date(last).toISOString(),
+        isActive,
+        calls: events.length,
+        tokens: { ...tokens, total },
+        costUsd,
+        costProvenance: classifyCostProvenance({ reportedCalls, estimatedCalls, unpricedCalls }),
+        unpricedCalls,
+        models,
+        elapsedMs,
+        remainingMs,
+        burnRatePerMinute,
+        projectedTokens,
+        projectedCostUsd,
+    };
+}
+/**
+ * Group usage events into billing blocks, oldest first.
+ *
+ * Events with an unparseable timestamp are ignored. Events are sorted before
+ * grouping, so callers may pass them in any order.
+ */
+export function computeBillingBlocks(events, options = {}) {
+    const durationMs = options.blockDurationMs ?? BILLING_BLOCK_DURATION_MS;
+    const alignToHour = options.alignToHour ?? true;
+    const nowMs = options.now === undefined ? Date.now() : toMs(options.now);
+    const sorted = events
+        .map(normalizeInput)
+        .filter((event) => event !== null)
+        .sort((a, b) => a.timestamp - b.timestamp);
+    const blocks = [];
+    let current = [];
+    let currentStart = 0;
+    for (const event of sorted) {
+        const previous = current[current.length - 1];
+        const opensNewBlock = !previous ||
+            event.timestamp >= currentStart + durationMs ||
+            event.timestamp - previous.timestamp > durationMs;
+        if (opensNewBlock) {
+            if (current.length > 0)
+                blocks.push(buildBlock(current, currentStart, durationMs, nowMs));
+            current = [];
+            currentStart = alignToHour ? floorToUtcHour(event.timestamp) : event.timestamp;
+        }
+        current.push(event);
+    }
+    if (current.length > 0)
+        blocks.push(buildBlock(current, currentStart, durationMs, nowMs));
+    return blocks;
+}
+/** The block that is still open at the calculator's `now`, if any. */
+export function findActiveBillingBlock(blocks) {
+    for (let index = blocks.length - 1; index >= 0; index -= 1) {
+        if (blocks[index].isActive)
+            return blocks[index];
+    }
+    return null;
+}

package/dist/esm/usage/claudeUsageDedupe.js

@@ -0,0 +1,189 @@
+/**
+ * Claude Code writes one API response as several JSONL lines — one per content
+ * block — and every line repeats that response's `message.usage`. Streaming
+ * also means early lines can carry a partial `output_tokens` (often 1) that a
+ * later line of the same `message.id` supersedes. Summing every line
+ * therefore roughly doubles a session's tokens and cost.
+ *
+ * The correct rule is "the last copy of a message's usage wins", but readers
+ * stream events and cannot retract what they already emitted. So the first
+ * line carries the usage as a normal call, identical repeats are stripped, and
+ * a repeat that grew emits only the growth as a `usageKind: 'correction'`
+ * top-up. Consumers add corrections to token and cost totals without counting
+ * another call or context sample.
+ *
+ * Browser-safe: no Node imports.
+ *
+ * @module usage/claudeUsageDedupe
+ */
+import { normalizeProviderUsage } from '../usageNormalization';
+/** Claude Code's placeholder model for locally generated (unbilled) messages. */
+export const SYNTHETIC_MODEL = '<synthetic>';
+const DEFAULT_MAX_KEYS = 4096;
+/** Attach Anthropic-semantics normalized usage and Claude Code provenance to an event. */
+export function normalizeClaudeUsage(event) {
+    const message = event.message;
+    const usage = message?.usage;
+    if (!message || !usage) {
+        return {
+            ...event,
+            providerMetadata: {
+                ...event.providerMetadata,
+                providerId: 'claude-code',
+                source: 'claude-code-jsonl',
+            },
+        };
+    }
+    return {
+        ...event,
+        message: {
+            ...message,
+            normalizedUsage: normalizeProviderUsage({
+                semantics: 'anthropic',
+                provider: 'anthropic',
+                source: 'claude-code-jsonl',
+                model: message.model,
+                inputTokens: usage.input_tokens,
+                outputTokens: usage.output_tokens,
+                cacheReadTokens: usage.cache_read_input_tokens,
+                cacheWriteTokens: usage.cache_creation_input_tokens,
+                reasoningTokens: usage.reasoning_tokens,
+                reasoningIncludedInOutput: false,
+                reportedCostUsd: usage.reported_cost,
+            }),
+        },
+        providerMetadata: {
+            ...event.providerMetadata,
+            providerId: 'claude-code',
+            source: 'claude-code-jsonl',
+        },
+    };
+}
+function bucketsOf(usage) {
+    return {
+        input: usage.uncachedInputTokens,
+        cacheRead: usage.cacheReadTokens,
+        cacheWrite: usage.cacheWriteTokens,
+        output: usage.outputTokens,
+        reasoning: usage.reasoningTokens,
+    };
+}
+function stripUsage(event) {
+    if (!event.message)
+        return event;
+    const message = { ...event.message };
+    delete message.usage;
+    delete message.normalizedUsage;
+    return { ...event, message };
+}
+/**
+ * Per-reader dedupe state. Split lines of one response are adjacent, so a
+ * bounded map (oldest keys evicted first) is enough.
+ */
+export class ClaudeUsageDeduper {
+    maxKeys;
+    seen = new Map();
+    constructor(maxKeys = DEFAULT_MAX_KEYS) {
+        this.maxKeys = maxKeys;
+    }
+    /**
+     * Returns the event with its usage adjusted: unchanged for the first line of
+     * a message, stripped for an identical repeat or a `<synthetic>` message,
+     * and replaced by the growth (marked as a correction) for a repeat that grew.
+     * Events must already carry `message.normalizedUsage`.
+     */
+    apply(event) {
+        const message = event.message;
+        const usage = message?.normalizedUsage;
+        if (!message || !usage)
+            return event;
+        if (message.model === SYNTHETIC_MODEL)
+            return stripUsage(event);
+        const id = message.id;
+        if (!id)
+            return event;
+        const current = bucketsOf(usage);
+        const previous = this.seen.get(id);
+        if (!previous) {
+            this.remember(id, current);
+            return event;
+        }
+        const delta = {
+            input: Math.max(0, current.input - previous.input),
+            cacheRead: Math.max(0, current.cacheRead - previous.cacheRead),
+            cacheWrite: Math.max(0, current.cacheWrite - previous.cacheWrite),
+            output: Math.max(0, current.output - previous.output),
+            reasoning: Math.max(0, current.reasoning - previous.reasoning),
+        };
+        this.remember(id, {
+            input: previous.input + delta.input,
+            cacheRead: previous.cacheRead + delta.cacheRead,
+            cacheWrite: previous.cacheWrite + delta.cacheWrite,
+            output: previous.output + delta.output,
+            reasoning: previous.reasoning + delta.reasoning,
+        });
+        if (!delta.input &&
+            !delta.cacheRead &&
+            !delta.cacheWrite &&
+            !delta.output &&
+            !delta.reasoning) {
+            return stripUsage(event);
+        }
+        const cacheInclusiveInputTokens = delta.input + delta.cacheRead + delta.cacheWrite;
+        const billableOutputTokens = delta.output + (usage.reasoningIncludedInOutput ? 0 : delta.reasoning);
+        const normalizedUsage = {
+            uncachedInputTokens: delta.input,
+            cacheReadTokens: delta.cacheRead,
+            cacheWriteTokens: delta.cacheWrite,
+            outputTokens: delta.output,
+            reasoningTokens: delta.reasoning,
+            reasoningIncludedInOutput: usage.reasoningIncludedInOutput,
+            cacheInclusiveInputTokens,
+            billableOutputTokens,
+            totalTokens: cacheInclusiveInputTokens + billableOutputTokens,
+            ...(usage.model ? { model: usage.model } : {}),
+            provenance: usage.provenance,
+        };
+        const messageUsage = {
+            input_tokens: delta.input,
+            output_tokens: delta.output,
+            cache_creation_input_tokens: delta.cacheWrite,
+            cache_read_input_tokens: delta.cacheRead,
+            ...(delta.reasoning ? { reasoning_tokens: delta.reasoning } : {}),
+        };
+        return {
+            ...event,
+            message: { ...message, usage: messageUsage, normalizedUsage, usageKind: 'correction' },
+        };
+    }
+    /** Whether a message id has already been counted by this deduper. */
+    has(id) {
+        return this.seen.has(id);
+    }
+    reset() {
+        this.seen.clear();
+    }
+    remember(id, buckets) {
+        this.seen.delete(id);
+        this.seen.set(id, buckets);
+        if (this.seen.size > this.maxKeys) {
+            const oldest = this.seen.keys().next().value;
+            if (oldest !== undefined)
+                this.seen.delete(oldest);
+        }
+    }
+}
+/**
+ * Deduplicated normalized usage for one raw Claude Code JSONL assistant line,
+ * or null when the line carries none (or only repeats usage already counted).
+ */
+export function dedupedRawClaudeUsage(raw, deduper) {
+    if (!raw || raw.type !== 'assistant' || !raw.message?.usage)
+        return null;
+    const event = deduper.apply(normalizeClaudeUsage({
+        type: 'assistant',
+        timestamp: raw.timestamp ?? '',
+        message: raw.message,
+    }));
+    return event.message?.normalizedUsage ?? null;
+}