sidekick-shared 0.27.2 → 0.27.3

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

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() {
@@ -239,7 +309,8 @@ async function collectUsageEvents(options) {
         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 +328,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.3",
   "description": "Shared data access layer for Sidekick — readers, types, providers, credentials, quota",
   "keywords": [
     "claude-code",