sidekick-shared 0.27.2 → 0.27.4

package/dist/usage/claudeUsageDedupe.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 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 { type NormalizedUsage } from '../usageNormalization';
+import type { SessionEvent } from '../types/sessionEvent';
+/** Claude Code's placeholder model for locally generated (unbilled) messages. */
+export declare const SYNTHETIC_MODEL = "<synthetic>";
+/** Attach Anthropic-semantics normalized usage and Claude Code provenance to an event. */
+export declare function normalizeClaudeUsage(event: SessionEvent): SessionEvent;
+/**
+ * Per-reader dedupe state. Split lines of one response are adjacent, so a
+ * bounded map (oldest keys evicted first) is enough.
+ */
+export declare class ClaudeUsageDeduper {
+    private readonly maxKeys;
+    private readonly seen;
+    constructor(maxKeys?: number);
+    /**
+     * 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: SessionEvent): SessionEvent;
+    /** Whether a message id has already been counted by this deduper. */
+    has(id: string): boolean;
+    reset(): void;
+    private remember;
+}
+/**
+ * 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 declare function dedupedRawClaudeUsage(raw: {
+    type?: string;
+    timestamp?: string;
+    message?: SessionEvent['message'];
+} | null | undefined, deduper: ClaudeUsageDeduper): NormalizedUsage | null;

package/dist/usage/claudeUsageDedupe.js

@@ -0,0 +1,195 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeUsageDeduper = exports.SYNTHETIC_MODEL = void 0;
+exports.normalizeClaudeUsage = normalizeClaudeUsage;
+exports.dedupedRawClaudeUsage = dedupedRawClaudeUsage;
+const usageNormalization_1 = require("../usageNormalization");
+/** Claude Code's placeholder model for locally generated (unbilled) messages. */
+exports.SYNTHETIC_MODEL = '<synthetic>';
+const DEFAULT_MAX_KEYS = 4096;
+/** Attach Anthropic-semantics normalized usage and Claude Code provenance to an event. */
+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: (0, usageNormalization_1.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.
+ */
+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 === exports.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);
+        }
+    }
+}
+exports.ClaudeUsageDeduper = ClaudeUsageDeduper;
+/**
+ * Deduplicated normalized usage for one raw Claude Code JSONL assistant line,
+ * or null when the line carries none (or only repeats usage already counted).
+ */
+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;
+}

package/dist/usage/subagentUsage.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Accumulate normalized usage into a subagent's token fields so every
+ * provider's `scanSubagents()` reports the same four buckets and the same
+ * cache-inclusive total as `summarizeTokens()`.
+ *
+ * Browser-safe: no Node imports.
+ *
+ * @module usage/subagentUsage
+ */
+import type { NormalizedUsage } from '../usageNormalization';
+import type { SubagentStats } from '../types/sessionEvent';
+/** Add one usage record (a call or a correction) to a subagent's token totals. */
+export declare function addUsageToSubagent(stats: SubagentStats, usage: NormalizedUsage): void;

package/dist/usage/subagentUsage.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Accumulate normalized usage into a subagent's token fields so every
+ * provider's `scanSubagents()` reports the same four buckets and the same
+ * cache-inclusive total as `summarizeTokens()`.
+ *
+ * Browser-safe: no Node imports.
+ *
+ * @module usage/subagentUsage
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addUsageToSubagent = addUsageToSubagent;
+/** Add one usage record (a call or a correction) to a subagent's token totals. */
+function addUsageToSubagent(stats, usage) {
+    stats.inputTokens += usage.uncachedInputTokens;
+    stats.outputTokens += usage.outputTokens;
+    stats.cacheReadTokens = (stats.cacheReadTokens ?? 0) + usage.cacheReadTokens;
+    stats.cacheWriteTokens = (stats.cacheWriteTokens ?? 0) + usage.cacheWriteTokens;
+    stats.reasoningTokens = (stats.reasoningTokens ?? 0) + usage.reasoningTokens;
+    stats.totalTokens = (stats.totalTokens ?? 0) + usage.totalTokens;
+}

package/dist/usage/usageEvents.d.ts

@@ -10,6 +10,11 @@
  * catalog refresh never leaves stale costs behind. Cache files are touched on
  * every hit and pruned least-recently-used, once per collection.
  *
+ * A Claude Code session's subagents write their own transcripts under
+ * `<sessionId>/subagents/`; their usage is attributed to the parent session
+ * and their sizes and mtimes join the fingerprint. (Codex spawned subagents
+ * are top-level rollouts, already listed as sessions of their own.)
+ *
  * Node-only: reads session files and the cache directory.
  *
  * @module usage/usageEvents
@@ -17,8 +22,12 @@
 import type { ProviderId, SessionProviderBase, SessionProviderDiagnostic } from '../providers/types';
 import type { TokenTotals } from '../types/historicalData';
 import type { PricingProvenance } from '../usageNormalization';
-/** Bump when the cached record shape changes; older files are re-read. */
-export declare const USAGE_CACHE_VERSION = 1;
+/**
+ * Bump when the cached record shape or the counting rules change; older files
+ * are re-read. v2: Claude split lines and duplicate Codex `token_count` events
+ * are counted once, and Claude subagent transcripts are included.
+ */
+export declare const USAGE_CACHE_VERSION = 2;
 /**
  * Most-recently-used cache files kept on disk. Sized for a busy month of
  * sessions (files are a few KB each); a collection larger than this still
@@ -69,6 +78,13 @@ export interface CollectUsageEventsOptions {
     /** Skip the on-disk cache entirely. */
     noCache?: boolean;
     onDiagnostic?: (diagnostic: SessionProviderDiagnostic) => void;
+    /**
+     * Stops the collection before listing and between sessions; the promise
+     * rejects with the signal's reason (an `AbortError` by default). Sessions
+     * read before the abort keep their cache entries; no partial session is
+     * cached.
+     */
+    signal?: AbortSignal;
 }
 export interface CollectUsageEventsResult {
     /** Events within the window, oldest first. */

package/dist/usage/usageEvents.js

@@ -11,6 +11,11 @@
  * catalog refresh never leaves stale costs behind. Cache files are touched on
  * every hit and pruned least-recently-used, once per collection.
  *
+ * A Claude Code session's subagents write their own transcripts under
+ * `<sessionId>/subagents/`; their usage is attributed to the parent session
+ * and their sizes and mtimes join the fingerprint. (Codex spawned subagents
+ * are top-level rollouts, already listed as sessions of their own.)
+ *
  * Node-only: reads session files and the cache directory.
  *
  * @module usage/usageEvents
@@ -59,8 +64,12 @@ const paths_1 = require("../paths");
 const sessionPreviews_1 = require("../sessionPreviews");
 const usageNormalization_1 = require("../usageNormalization");
 const atomic_1 = require("../writers/atomic");
-/** Bump when the cached record shape changes; older files are re-read. */
-exports.USAGE_CACHE_VERSION = 1;
+/**
+ * Bump when the cached record shape or the counting rules change; older files
+ * are re-read. v2: Claude split lines and duplicate Codex `token_count` events
+ * are counted once, and Claude subagent transcripts are included.
+ */
+exports.USAGE_CACHE_VERSION = 2;
 /**
  * Most-recently-used cache files kept on disk. Sized for a busy month of
  * sessions (files are a few KB each); a collection larger than this still
@@ -188,20 +197,81 @@ function priceCachedEvent(cached, provider, sessionId, project) {
         costProvenance: priced.source,
     };
 }
-function readSessionUsage(provider, preview) {
-    const reader = provider.createReader(preview.filePath);
+const CLAUDE_AGENT_FILE = /^agent-.+\.jsonl$/;
+/** Claude Code subagent transcripts of a session, sorted by name. */
+function claudeSubagentFiles(preview) {
+    if (preview.provider !== 'claude-code')
+        return [];
+    const dir = path.join(path.dirname(preview.filePath), preview.sessionId, 'subagents');
+    let names;
+    try {
+        names = fs.readdirSync(dir).filter((name) => CLAUDE_AGENT_FILE.test(name));
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    for (const name of names.sort()) {
+        try {
+            const stat = fs.statSync(path.join(dir, name));
+            files.push({
+                path: path.join(dir, name),
+                name,
+                sizeBytes: stat.size,
+                modifiedAt: stat.mtimeMs,
+            });
+        }
+        catch {
+            // Removed between listing and stat; the next collection re-reads.
+        }
+    }
+    return files;
+}
+function sessionFingerprint(preview, subagents) {
+    const base = `${preview.sizeBytes}:${preview.modifiedAt}`;
+    if (subagents.length === 0)
+        return base;
+    return `${base}|${subagents.map((f) => `${f.name}:${f.sizeBytes}:${f.modifiedAt}`).join(',')}`;
+}
+function readTranscriptUsage(provider, filePath, cached) {
+    const reader = provider.createReader(filePath);
     const events = reader.readAll();
     reader.flush();
-    const cached = [];
+    // A correction tops up the call its message already recorded, so it merges
+    // into that record instead of counting as another call.
+    const byMessageId = new Map();
     for (const event of events) {
         const usage = (0, usageNormalization_1.extractNormalizedUsage)(event);
         if (!usage)
             continue;
+        const messageId = event.message?.id;
+        const target = event.message?.usageKind === 'correction' && messageId
+            ? byMessageId.get(messageId)
+            : undefined;
+        if (target) {
+            target.i += usage.uncachedInputTokens;
+            target.o += usage.outputTokens;
+            target.cw += usage.cacheWriteTokens;
+            target.cr += usage.cacheReadTokens;
+            target.bo += usage.billableOutputTokens;
+            target.tt += usage.totalTokens;
+            continue;
+        }
         const timestamp = Date.parse(event.timestamp);
         if (!Number.isFinite(timestamp))
             continue;
-        cached.push(cachedEventFromUsage(usage, timestamp, event.message?.model ?? usage.model ?? 'unknown'));
+        const record = cachedEventFromUsage(usage, timestamp, event.message?.model ?? usage.model ?? 'unknown');
+        cached.push(record);
+        if (messageId)
+            byMessageId.set(messageId, record);
     }
+}
+function readSessionUsage(provider, preview, subagents) {
+    const cached = [];
+    readTranscriptUsage(provider, preview.filePath, cached);
+    for (const file of subagents)
+        readTranscriptUsage(provider, file.path, cached);
+    cached.sort((a, b) => a.t - b.t);
     return cached;
 }
 function yieldToEventLoop() {
@@ -220,12 +290,15 @@ async function collectUsageEvents(options) {
     const untilMs = toMs(options.until, 'until');
     const cacheDir = options.cacheDir ?? getUsageCacheDir();
     const useCache = !options.noCache;
+    const signal = options.signal;
+    signal?.throwIfAborted();
     const listed = await (0, sessionPreviews_1.listSessionPreviewsAsync)(options.providers, {
         since: options.since,
         workspacePath: options.workspacePath,
         limit: Number.MAX_SAFE_INTEGER,
         concurrency: options.concurrency,
     });
+    signal?.throwIfAborted();
     const diagnostics = [...listed.diagnostics];
     for (const diagnostic of listed.diagnostics)
         options.onDiagnostic?.(diagnostic);
@@ -236,10 +309,12 @@ async function collectUsageEvents(options) {
     let cacheMisses = 0;
     let wroteCache = false;
     for (const preview of listed.previews) {
+        signal?.throwIfAborted();
         const provider = providerById.get(preview.provider);
         if (!provider)
             continue;
-        const fingerprint = `${preview.sizeBytes}:${preview.modifiedAt}`;
+        const subagentFiles = claudeSubagentFiles(preview);
+        const fingerprint = sessionFingerprint(preview, subagentFiles);
         const filePath = cacheFilePath(cacheDir, preview.provider, preview.sessionId);
         let cachedEvents = null;
         let project = preview.workspacePath;
@@ -257,7 +332,7 @@ async function collectUsageEvents(options) {
         if (!cachedEvents) {
             cacheMisses += 1;
             try {
-                cachedEvents = readSessionUsage(provider, preview);
+                cachedEvents = readSessionUsage(provider, preview, subagentFiles);
             }
             catch (error) {
                 const diagnostic = {

package/dist/watchers/eventBridge.js

@@ -29,6 +29,7 @@ function toFollowEvents(event, providerId) {
         ? { read: usage.cache_read_input_tokens || 0, write: usage.cache_creation_input_tokens || 0 }
         : undefined;
     const cost = usage?.reported_cost;
+    const usageKind = usage ? event.message?.usageKind : undefined;
     const model = event.message?.model;
     const rateLimits = event.rateLimits;
     switch (event.type) {
@@ -94,6 +95,7 @@ function toFollowEvents(event, providerId) {
                     summary: text || '(thinking...)',
                     tokens,
                     cacheTokens,
+                    ...(usageKind ? { usageKind } : {}),
                     cost,
                     model,
                     raw: event,
@@ -104,6 +106,8 @@ function toFollowEvents(event, providerId) {
                 const last = events[events.length - 1];
                 last.tokens = tokens;
                 last.cacheTokens = cacheTokens;
+                if (usageKind)
+                    last.usageKind = usageKind;
                 last.cost = cost;
             }
             break;
@@ -158,6 +162,7 @@ function toFollowEvents(event, providerId) {
                 summary: label && text ? `${label}: ${text}` : summary,
                 tokens,
                 cacheTokens,
+                ...(usageKind ? { usageKind } : {}),
                 cost,
                 model,
                 rateLimits,

package/dist/watchers/jsonlWatcher.d.ts

@@ -11,6 +11,9 @@ export declare class JsonlSessionWatcher implements SessionWatcher {
     private tail;
     private startOffset;
     private codexInPlanMode;
+    private readonly claudeUsageDeduper;
+    /** Last Codex cumulative usage seen; repeated `token_count` events carry the same value. */
+    private codexPrevTotal;
     constructor(providerId: ProviderId, sessionPath: string, callbacks: SessionWatcherCallbacks);
     get isActive(): boolean;
     /** Seek to a committed byte offset before starting replay. */
@@ -20,5 +23,7 @@ export declare class JsonlSessionWatcher implements SessionWatcher {
     start(replay: boolean): void;
     stop(): void;
     private handleRawEvent;
+    /** One call's usage from a token_count `info`, skipping duplicate events. */
+    private codexCallUsage;
     private normalizeCodexEvent;
 }

package/dist/watchers/jsonlWatcher.js

@@ -8,12 +8,29 @@ exports.JsonlSessionWatcher = void 0;
 const jsonlTail_1 = require("./jsonlTail");
 const codexParser_1 = require("../parsers/codexParser");
 const toolSummary_1 = require("../formatters/toolSummary");
+const claudeUsageDedupe_1 = require("../usage/claudeUsageDedupe");
 // ── Normalizers ──
-function normalizeClaudeCodeEvent(raw) {
+/**
+ * Split lines of one Claude response repeat its usage; run the raw usage
+ * through the shared deduper so each response is counted once (last copy wins).
+ */
+function dedupedClaudeUsage(raw, deduper) {
+    if (!raw.message?.usage)
+        return { usage: undefined, usageKind: undefined };
+    const event = deduper.apply((0, claudeUsageDedupe_1.normalizeClaudeUsage)({
+        type: 'assistant',
+        timestamp: raw.timestamp || '',
+        message: raw.message,
+    }));
+    return { usage: event.message?.usage, usageKind: event.message?.usageKind };
+}
+function normalizeClaudeCodeEvent(raw, deduper) {
     const events = [];
     const ts = raw.timestamp || new Date().toISOString();
     const permissionMode = raw.permissionMode;
-    const usage = raw.message?.usage;
+    const { usage, usageKind } = raw.type === 'assistant'
+        ? dedupedClaudeUsage(raw, deduper)
+        : { usage: undefined, usageKind: undefined };
     const tokens = usage
         ? { input: usage.input_tokens || 0, output: usage.output_tokens || 0 }
         : undefined;
@@ -83,6 +100,7 @@ function normalizeClaudeCodeEvent(raw) {
                 summary: text || '(thinking...)',
                 tokens,
                 cacheTokens,
+                ...(usageKind ? { usageKind } : {}),
                 cost,
                 model,
                 raw,
@@ -93,6 +111,8 @@ function normalizeClaudeCodeEvent(raw) {
             const last = events[events.length - 1];
             last.tokens = tokens;
             last.cacheTokens = cacheTokens;
+            if (usageKind)
+                last.usageKind = usageKind;
             last.cost = cost;
         }
     }
@@ -190,6 +210,9 @@ class JsonlSessionWatcher {
     tail;
     startOffset;
     codexInPlanMode = false;
+    claudeUsageDeduper = new claudeUsageDedupe_1.ClaudeUsageDeduper();
+    /** Last Codex cumulative usage seen; repeated `token_count` events carry the same value. */
+    codexPrevTotal;
     constructor(providerId, sessionPath, callbacks) {
         this.providerId = providerId;
         this.sessionPath = sessionPath;
@@ -223,17 +246,25 @@ class JsonlSessionWatcher {
     stop() {
         this.tail?.stop();
         this.codexInPlanMode = false;
+        this.claudeUsageDeduper.reset();
+        this.codexPrevTotal = undefined;
     }
     handleRawEvent(event) {
         // For codex, raw events don't match RawSessionEvent shape exactly, but
         // JsonlParser parses any JSON object. Cast to Record for codex normalizer.
         const followEvents = this.providerId === 'codex'
             ? this.normalizeCodexEvent(event)
-            : normalizeClaudeCodeEvent(event);
+            : normalizeClaudeCodeEvent(event, this.claudeUsageDeduper);
         for (const fe of followEvents) {
             this.callbacks.onEvent(fe);
         }
     }
+    /** One call's usage from a token_count `info`, skipping duplicate events. */
+    codexCallUsage(info) {
+        const resolved = (0, codexParser_1.resolveCodexCallUsage)(info, this.codexPrevTotal ?? null);
+        this.codexPrevTotal = resolved.total ?? undefined;
+        return resolved.usage;
+    }
     normalizeCodexEvent(raw) {
         const events = [];
         const ts = raw.timestamp || new Date().toISOString();
@@ -332,7 +363,7 @@ class JsonlSessionWatcher {
             const evtType = payload?.type;
             if (evtType === 'token_count') {
                 const info = payload?.info;
-                const usage = (info?.last_token_usage || info?.total_token_usage);
+                const usage = this.codexCallUsage(info);
                 const rl = payload?.rate_limits;
                 const rateLimits = rl ? extractRateLimits(rl) : undefined;
                 if (usage || rateLimits) {
@@ -343,12 +374,16 @@ class JsonlSessionWatcher {
                         summary: usage
                             ? `Tokens: ${usage.input_tokens ?? 0} in / ${usage.output_tokens ?? 0} out`
                             : 'Rate limits updated',
+                        // Codex input includes cached input; FollowEvent buckets are disjoint.
                         tokens: usage
                             ? {
-                                input: usage.input_tokens || 0,
+                                input: Math.max(0, (usage.input_tokens || 0) - (usage.cached_input_tokens || 0)),
                                 output: usage.output_tokens || 0,
                             }
                             : undefined,
+                        cacheTokens: usage?.cached_input_tokens
+                            ? { read: usage.cached_input_tokens, write: 0 }
+                            : undefined,
                         rateLimits,
                         raw,
                     });

package/dist/watchers/types.d.ts

@@ -18,6 +18,11 @@ export interface FollowEvent {
         read: number;
         write: number;
     };
+    /**
+     * `'correction'` marks tokens that top up a response already counted (a later
+     * split line reported more). Absent means a regular call.
+     */
+    usageKind?: 'call' | 'correction';
     cost?: number;
     toolName?: string;
     toolInput?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sidekick-shared",
-  "version": "0.27.2",
+  "version": "0.27.4",
   "description": "Shared data access layer for Sidekick — readers, types, providers, credentials, quota",
   "keywords": [
     "claude-code",