sidekick-shared 0.27.2 → 0.27.3

package/dist/parsers/subagentTraceParser.js

@@ -52,6 +52,9 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const toolSummary_1 = require("../formatters/toolSummary");
 const noiseClassifier_1 = require("../formatters/noiseClassifier");
+const claudeUsageDedupe_1 = require("../usage/claudeUsageDedupe");
+const subagentUsage_1 = require("../usage/subagentUsage");
+const subagentScanner_1 = require("./subagentScanner");
 // ── Constants ──
 const AGENT_FILE_PATTERN = /^agent-(.+)\.jsonl$/;
 // ── Public API ──
@@ -101,8 +104,8 @@ function parseAgentTrace(filePath, agentId) {
         const toolCalls = [];
         let agentType;
         let description;
-        let inputTokens = 0;
-        let outputTokens = 0;
+        const tokens = { agentId, toolCalls: [], inputTokens: 0, outputTokens: 0 };
+        const usageDeduper = new claudeUsageDedupe_1.ClaudeUsageDeduper();
         let startTime;
         let endTime;
         for (const line of lines) {
@@ -153,11 +156,10 @@ function parseAgentTrace(filePath, agentId) {
                     isHardNoise: hardNoise,
                 });
                 // Extract token usage
-                if (raw.type === 'assistant' && raw.message?.usage) {
-                    const usage = raw.message.usage;
-                    inputTokens += usage.input_tokens || 0;
-                    outputTokens += usage.output_tokens || 0;
-                }
+                // Split lines of one response repeat its usage; count each response once.
+                const usage = (0, claudeUsageDedupe_1.dedupedRawClaudeUsage)(raw, usageDeduper);
+                if (usage)
+                    (0, subagentUsage_1.addUsageToSubagent)(tokens, usage);
                 // Extract tool calls
                 if (raw.type === 'assistant' && Array.isArray(raw.message?.content)) {
                     for (const block of raw.message.content) {
@@ -194,7 +196,10 @@ function parseAgentTrace(filePath, agentId) {
                 // Skip malformed lines
             }
         }
-        if (events.length === 0 && !agentType && !description && inputTokens === 0) {
+        const meta = (0, subagentScanner_1.readAgentMeta)(filePath);
+        agentType = meta.agentType ?? agentType;
+        description = meta.description ?? description;
+        if (events.length === 0 && !agentType && !description && !tokens.totalTokens) {
             return null;
         }
         const durationMs = startTime && endTime ? endTime.getTime() - startTime.getTime() : undefined;
@@ -209,8 +214,12 @@ function parseAgentTrace(filePath, agentId) {
                 agentType,
                 description,
                 toolCalls,
-                inputTokens,
-                outputTokens,
+                inputTokens: tokens.inputTokens,
+                outputTokens: tokens.outputTokens,
+                cacheReadTokens: tokens.cacheReadTokens ?? 0,
+                cacheWriteTokens: tokens.cacheWriteTokens ?? 0,
+                reasoningTokens: tokens.reasoningTokens ?? 0,
+                totalTokens: tokens.totalTokens ?? 0,
                 startTime,
                 endTime,
                 durationMs,

package/dist/providers/claudeCode.js

@@ -50,13 +50,13 @@ const string_decoder_1 = require("string_decoder");
 const sessionContext_1 = require("../context/sessionContext");
 const sessionStats_1 = require("../sessionStats");
 const jsonl_1 = require("../parsers/jsonl");
+const claudeUsageDedupe_1 = require("../usage/claudeUsageDedupe");
 const diagnostics_1 = require("./diagnostics");
 const directoryListingCache_1 = require("./directoryListingCache");
 const sessionPathResolver_1 = require("../parsers/sessionPathResolver");
 const subagentScanner_1 = require("../parsers/subagentScanner");
 const modelContext_1 = require("../modelContext");
 const sessionEvent_1 = require("../schemas/sessionEvent");
-const usageNormalization_1 = require("../usageNormalization");
 /** Type guard for content blocks with a `type` string property */
 function isTypedBlock(block) {
     return (block !== null &&
@@ -163,12 +163,15 @@ class ClaudeCodeReader {
     events = [];
     _wasTruncated = false;
     decoder = new string_decoder_1.StringDecoder('utf8');
-    constructor(sessionPath) {
+    /** Split lines of one response repeat its usage; count each response once. */
+    usageDeduper;
+    constructor(sessionPath, usageDeduper) {
         this.sessionPath = sessionPath;
+        this.usageDeduper = usageDeduper ?? new claudeUsageDedupe_1.ClaudeUsageDeduper();
         this.parser = new jsonl_1.JsonlParser({
             onEvent: (raw) => {
                 for (const event of (0, sessionEvent_1.extractSessionEvents)(raw)) {
-                    this.events.push(normalizeClaudeUsage(event));
+                    this.events.push(this.usageDeduper.apply((0, claudeUsageDedupe_1.normalizeClaudeUsage)(event)));
                 }
             },
             onError: (_err, _line) => {
@@ -192,6 +195,7 @@ class ClaudeCodeReader {
                 this.committedPosition = 0;
                 this.parser.reset();
                 this.decoder = new string_decoder_1.StringDecoder('utf8');
+                this.usageDeduper.reset();
             }
             // No new content
             if (currentSize <= this.filePosition) {
@@ -230,6 +234,7 @@ class ClaudeCodeReader {
         this.committedPosition = 0;
         this.parser.reset();
         this.decoder = new string_decoder_1.StringDecoder('utf8');
+        this.usageDeduper.reset();
         this._wasTruncated = false;
     }
     exists() {
@@ -255,44 +260,6 @@ class ClaudeCodeReader {
         return this._wasTruncated;
     }
 }
-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',
-        },
-    };
-}
 /**
  * Session provider for Claude Code CLI.
  *

package/dist/providers/codex.js

@@ -52,6 +52,7 @@ const sessionContext_1 = require("../context/sessionContext");
 const sessionStats_1 = require("../sessionStats");
 const codexParser_1 = require("../parsers/codexParser");
 const codexDatabase_1 = require("./codexDatabase");
+const subagentStatsCache_1 = require("../parsers/subagentStatsCache");
 const codexProfiles_1 = require("../codexProfiles");
 const rolloutWalker_1 = require("./rolloutWalker");
 const directoryListingCache_1 = require("./directoryListingCache");
@@ -59,6 +60,7 @@ const diagnostics_1 = require("./diagnostics");
 const modelContext_1 = require("../modelContext");
 const observedContextWindows_1 = require("../observedContextWindows");
 const usageNormalization_1 = require("../usageNormalization");
+const subagentUsage_1 = require("../usage/subagentUsage");
 // ---------------------------------------------------------------------------
 // Helper functions
 // ---------------------------------------------------------------------------
@@ -1048,16 +1050,24 @@ class CodexProvider {
         // Codex tracks forked sessions via forked_from_id in session_meta.
         // Use DB when available, fall back to filesystem scanning.
         const subagents = [];
-        // DB approach: query threads table for forked children
+        // DB approach: spawned subagents (parent recorded in `threads.source`),
+        // plus forked children on older schemas that carry `forked_from_id`.
         const db = this.ensureDb();
         if (db) {
-            const forkedThreads = db.getThreadsByForkedFromId(sessionId);
-            for (const thread of forkedThreads) {
-                const stats = this.buildSubagentStats(thread.id, thread.rollout_path, thread.title);
-                if (stats)
-                    subagents.push(stats);
+            const seen = new Set();
+            const children = [
+                ...db.getSpawnedChildThreads(sessionId),
+                ...db.getThreadsByForkedFromId(sessionId),
+            ].filter((thread) => !seen.has(thread.id) && seen.add(thread.id));
+            for (const thread of children) {
+                const built = (0, subagentStatsCache_1.cachedSubagentStats)(thread.rollout_path, () => this.buildSubagentStats(thread.id, thread.rollout_path, thread.title || thread.agent_nickname));
+                if (built) {
+                    subagents.push(thread.agent_role && !built.agentType
+                        ? { ...built, agentType: thread.agent_role }
+                        : built);
+                }
             }
-            if (forkedThreads.length > 0)
+            if (children.length > 0)
                 return subagents;
         }
         // Filesystem fallback: scan recent rollout files for a matching
@@ -1065,9 +1075,13 @@ class CodexProvider {
         // of enumerating the whole history and slicing afterwards.
         for (const file of findRolloutFilesInConfiguredHomes({ limit: 50 })) {
             const meta = readSessionMeta(file.path);
-            if (meta?.forked_from_id === sessionId) {
+            if (meta &&
+                (meta.forked_from_id === sessionId || (0, codexDatabase_1.spawnParentFromSource)(meta.source) === sessionId)) {
                 const childId = (0, rolloutWalker_1.extractRolloutSessionId)(path.basename(file.path));
-                const stats = this.buildSubagentStats(childId, file.path, meta.source);
+                // `source` is a plain string for top-level sessions but an object
+                // (`{ subagent: { thread_spawn: … } }`) for spawned children.
+                const description = typeof meta.source === 'string' ? meta.source : undefined;
+                const stats = (0, subagentStatsCache_1.cachedSubagentStats)(file.path, () => this.buildSubagentStats(childId, file.path, description));
                 if (stats)
                     subagents.push(stats);
             }
@@ -1119,11 +1133,11 @@ class CodexProvider {
                                 }
                             }
                         }
-                        // Accumulate tokens from usage events
-                        if (event.message?.usage) {
-                            stats.inputTokens += event.message.usage.input_tokens || 0;
-                            stats.outputTokens += event.message.usage.output_tokens || 0;
-                        }
+                        // Accumulate tokens from usage events (duplicate token_count events
+                        // are already dropped by the parser).
+                        const usage = (0, usageNormalization_1.extractNormalizedUsage)(event);
+                        if (usage)
+                            (0, subagentUsage_1.addUsageToSubagent)(stats, usage);
                     }
                 }
                 catch {

package/dist/providers/codexDatabase.d.ts

@@ -4,6 +4,8 @@
  */
 import type { CodexDbThread } from '../types/codex';
 import type { ProviderRuntimeStatus } from './types';
+/** Parent thread id recorded in a Codex `threads.source` JSON value, if any. */
+export declare function spawnParentFromSource(source: unknown): string | undefined;
 export declare class CodexDatabase {
     private readonly dbPath;
     private sqlite3Available;
@@ -29,8 +31,21 @@ export declare class CodexDatabase {
      * chunk of ids, so the inlined query stays clear of argv length limits.
      */
     getThreadsByIdsAsync(ids: readonly string[]): Promise<CodexDbThread[]>;
-    /** Get all threads forked from a given session ID. */
+    private threadColumns;
+    /** Column names of the `threads` table (cached; the schema varies across Codex versions). */
+    private getThreadColumns;
+    /**
+     * Get all threads forked from a given session ID. Older Codex schemas carry
+     * a `forked_from_id` column; newer ones drop it, so the query only runs
+     * when the column exists (otherwise it fails and reports a diagnostic).
+     */
     getThreadsByForkedFromId(parentId: string): CodexDbThread[];
+    /**
+     * Get the subagent threads a session spawned. Codex records the parent in
+     * the `source` JSON (`{"subagent":{"thread_spawn":{"parent_thread_id":…}}}`);
+     * the LIKE narrows the scan and the JSON parse confirms the match.
+     */
+    getSpawnedChildThreads(parentId: string): CodexDbThread[];
     /** Get the database file's mtime (ms epoch). Returns 0 if unavailable. */
     getDbMtime(): number;
 }

package/dist/providers/codexDatabase.js

@@ -38,6 +38,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CodexDatabase = void 0;
+exports.spawnParentFromSource = spawnParentFromSource;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
@@ -46,6 +47,25 @@ const child_process_1 = require("child_process");
  * element to sqlite3, so an unbounded list would hit E2BIG on large stores.
  */
 const SQL_ID_CHUNK_SIZE = 400;
+/** Parent thread id recorded in a Codex `threads.source` JSON value, if any. */
+function spawnParentFromSource(source) {
+    let parsed = source;
+    if (typeof source === 'string') {
+        if (!source.startsWith('{'))
+            return undefined;
+        try {
+            parsed = JSON.parse(source);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return undefined;
+    const parent = parsed
+        .subagent?.thread_spawn?.parent_thread_id;
+    return typeof parent === 'string' ? parent : undefined;
+}
 class CodexDatabase {
     dbPath;
     sqlite3Available = null;
@@ -196,10 +216,38 @@ class CodexDatabase {
         }
         return results;
     }
-    /** Get all threads forked from a given session ID. */
+    threadColumns = null;
+    /** Column names of the `threads` table (cached; the schema varies across Codex versions). */
+    getThreadColumns() {
+        if (!this.threadColumns) {
+            const rows = this.query("SELECT name FROM pragma_table_info('threads')");
+            if (rows.length === 0)
+                return new Set();
+            this.threadColumns = new Set(rows.map((row) => row.name));
+        }
+        return this.threadColumns;
+    }
+    /**
+     * Get all threads forked from a given session ID. Older Codex schemas carry
+     * a `forked_from_id` column; newer ones drop it, so the query only runs
+     * when the column exists (otherwise it fails and reports a diagnostic).
+     */
     getThreadsByForkedFromId(parentId) {
+        if (!this.getThreadColumns().has('forked_from_id'))
+            return [];
         return this.query('SELECT * FROM threads WHERE forked_from_id = ? ORDER BY created_at ASC', [parentId]);
     }
+    /**
+     * Get the subagent threads a session spawned. Codex records the parent in
+     * the `source` JSON (`{"subagent":{"thread_spawn":{"parent_thread_id":…}}}`);
+     * the LIKE narrows the scan and the JSON parse confirms the match.
+     */
+    getSpawnedChildThreads(parentId) {
+        if (!this.getThreadColumns().has('source'))
+            return [];
+        const rows = this.query('SELECT * FROM threads WHERE source LIKE ? ORDER BY created_at ASC', [`%${parentId}%`]);
+        return rows.filter((row) => spawnParentFromSource(row.source) === parentId);
+    }
     /** Get the database file's mtime (ms epoch). Returns 0 if unavailable. */
     getDbMtime() {
         try {

package/dist/providers/openCode.js

@@ -60,6 +60,8 @@ const sessionContext_1 = require("../context/sessionContext");
 const sessionStats_1 = require("../sessionStats");
 const openCodeParser_1 = require("../parsers/openCodeParser");
 const openCodeDatabase_1 = require("./openCodeDatabase");
+const usageNormalization_1 = require("../usageNormalization");
+const subagentUsage_1 = require("../usage/subagentUsage");
 const zaiQuota_1 = require("../zaiQuota");
 const diagnostics_1 = require("./diagnostics");
 const modelContext_1 = require("../modelContext");
@@ -1478,21 +1480,41 @@ class OpenCodeProvider {
                     const subtask = i < subtaskParts.length ? subtaskParts[i] : undefined;
                     // Aggregate tokens from child session messages
                     const childMessages = db.getMessagesForSession(child.id);
-                    let inputTokens = 0;
-                    let outputTokens = 0;
+                    const tokenTotals = {
+                        agentId: '',
+                        toolCalls: [],
+                        inputTokens: 0,
+                        outputTokens: 0,
+                    };
                     for (const msgRow of childMessages) {
                         try {
                             const msgData = JSON.parse(msgRow.data);
                             const tokens = msgData.tokens;
                             if (tokens) {
-                                inputTokens += tokens.input || 0;
-                                outputTokens += tokens.output || 0;
+                                // Same semantics as the main-session parser (openCodeParser).
+                                const cache = tokens.cache;
+                                const providerID = msgData.providerID;
+                                (0, subagentUsage_1.addUsageToSubagent)(tokenTotals, (0, usageNormalization_1.normalizeProviderUsage)({
+                                    semantics: providerID === 'openai'
+                                        ? 'openai'
+                                        : providerID === 'anthropic'
+                                            ? 'anthropic'
+                                            : 'sidekick',
+                                    provider: providerID ?? 'opencode',
+                                    inputTokens: tokens.input,
+                                    outputTokens: tokens.output,
+                                    cacheReadTokens: cache?.read,
+                                    cacheWriteTokens: cache?.write,
+                                    reasoningTokens: tokens.reasoning,
+                                    reasoningIncludedInOutput: providerID === 'openai',
+                                }));
                             }
                         }
                         catch {
                             // Skip malformed messages
                         }
                     }
+                    const { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, reasoningTokens, totalTokens, } = tokenTotals;
                     // Extract tool calls from child session parts
                     const childParts = db.getPartsForSession(child.id);
                     const toolCalls = [];
@@ -1547,6 +1569,10 @@ class OpenCodeProvider {
                         toolCalls,
                         inputTokens,
                         outputTokens,
+                        cacheReadTokens,
+                        cacheWriteTokens,
+                        reasoningTokens,
+                        totalTokens,
                         startTime,
                         endTime,
                         durationMs,

package/dist/report/htmlReportGenerator.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateHtmlReport = generateHtmlReport;
 const costProvenance_1 = require("../aggregation/costProvenance");
 const tokenSummary_1 = require("../tokenSummary");
+const sessionTokenTotals_1 = require("../sessionTokenTotals");
 const htmlHelpers_1 = require("./htmlHelpers");
 const logo_1 = require("./logo");
 /**
@@ -16,7 +17,7 @@ const logo_1 = require("./logo");
 function generateHtmlReport(metrics, transcript, options = {}) {
     const { sessionFileName, includeThinking = true, includeToolDetail = true, theme = 'dark', } = options;
     const duration = (0, htmlHelpers_1.formatDuration)(metrics.sessionStartTime, metrics.lastEventTime);
-    const totalTokens = (0, tokenSummary_1.summarizeTokens)(metrics.tokens).total;
+    const tokens = (0, sessionTokenTotals_1.combineSessionTokenTotals)(metrics.tokens, options.subagents ?? []);
     return `<!DOCTYPE html>
 <html lang="en" data-theme="${theme}">
 <head>
@@ -27,7 +28,7 @@ ${generateStyles()}
 </head>
 <body>
 ${generateHeader(metrics, sessionFileName, duration)}
-${generateStatsCards(metrics, totalTokens, duration)}
+${generateStatsCards(metrics, tokens, duration)}
 ${generateModelBreakdown(metrics)}
 ${generateToolBreakdown(metrics)}
 ${generateTranscriptControls()}
@@ -422,7 +423,9 @@ function generateHeader(metrics, sessionFileName, duration) {
   </div>
 </div>`;
 }
-function generateStatsCards(metrics, totalTokens, duration) {
+function generateStatsCards(metrics, tokens, duration) {
+    const main = tokens.mainThread;
+    const hasSubagents = tokens.subagents.length > 0;
     const toolCount = metrics.toolStats.reduce((sum, t) => sum + t.successCount + t.failureCount, 0);
     const cards = [
         { label: 'Messages', value: String(metrics.messageCount), sub: `${metrics.eventCount} events` },
@@ -432,14 +435,28 @@ function generateStatsCards(metrics, totalTokens, duration) {
             sub: metrics.sessionStartTime ? (0, htmlHelpers_1.formatTimestamp)(metrics.sessionStartTime) + ' start' : '',
         },
         {
-            label: tokenSummary_1.TOKEN_TOTAL_LABEL,
-            value: (0, htmlHelpers_1.fmtTokens)(totalTokens),
-            sub: `${(0, htmlHelpers_1.fmtTokens)(metrics.tokens.inputTokens)} in / ${(0, htmlHelpers_1.fmtTokens)(metrics.tokens.outputTokens)} out`,
+            label: hasSubagents ? `${tokenSummary_1.TOKEN_MAIN_THREAD_LABEL} — ${tokenSummary_1.TOKEN_TOTAL_LABEL}` : tokenSummary_1.TOKEN_TOTAL_LABEL,
+            value: (0, htmlHelpers_1.fmtTokens)(main.total),
+            sub: `${(0, htmlHelpers_1.fmtTokens)(main.input)} in · ${(0, htmlHelpers_1.fmtTokens)(main.cacheRead)} cache read · ${(0, htmlHelpers_1.fmtTokens)(main.cacheWrite)} cache write · ${(0, htmlHelpers_1.fmtTokens)(main.output)} out${main.billedOutsideBuckets > 0 ? ` · ${(0, htmlHelpers_1.fmtTokens)(main.billedOutsideBuckets)} reasoning` : ''}`,
         },
+        ...(hasSubagents
+            ? [
+                {
+                    label: `${tokenSummary_1.TOKEN_SUBAGENTS_LABEL} (${tokens.subagents.length})`,
+                    value: (0, htmlHelpers_1.fmtTokens)(tokens.subagentTotal.total),
+                    sub: `${(0, htmlHelpers_1.fmtTokens)(tokens.subagentTotal.cacheRead)} cache read · ${(0, htmlHelpers_1.fmtTokens)(tokens.subagentTotal.output)} out`,
+                },
+                {
+                    label: tokenSummary_1.TOKEN_SESSION_TOTAL_LABEL,
+                    value: (0, htmlHelpers_1.fmtTokens)(tokens.combined.total),
+                    sub: 'main thread + subagents',
+                },
+            ]
+            : []),
         {
-            label: 'Cache',
-            value: (0, htmlHelpers_1.fmtTokens)(metrics.tokens.cacheReadTokens),
-            sub: `${(0, htmlHelpers_1.fmtTokens)(metrics.tokens.cacheWriteTokens)} written`,
+            label: 'Cache hit',
+            value: main.cacheHitRatio === null ? '—' : `${Math.round(main.cacheHitRatio * 100)}%`,
+            sub: `${(0, htmlHelpers_1.fmtTokens)(main.cacheRead)} of ${(0, htmlHelpers_1.fmtTokens)(main.context)} context tokens`,
         },
         {
             label: 'Tool Calls',
@@ -474,7 +491,7 @@ function generateModelBreakdown(metrics) {
     return `<div class="section">
 <div class="section-title">Model Breakdown</div>
 <table>
-<thead><tr><th>Model</th><th>Calls</th><th>Total Tokens</th><th>In / Out</th><th>Cost</th></tr></thead>
+<thead><tr><th>Model</th><th>Calls</th><th>${tokenSummary_1.TOKEN_TOTAL_LABEL}</th><th>In / Out</th><th>Cost</th></tr></thead>
 <tbody>${rows}</tbody>
 </table>
 </div>`;
@@ -534,7 +551,12 @@ function renderMessage(entry, includeThinking, includeToolDetail) {
         ? `<span class="message-model">${(0, htmlHelpers_1.escapeHtml)(entry.model)}</span>`
         : '';
     const tokenStr = entry.usage
-        ? `<span class="message-tokens">${(0, htmlHelpers_1.fmtTokens)(entry.usage.input_tokens + entry.usage.output_tokens)} tokens</span>`
+        ? `<span class="message-tokens">${(0, htmlHelpers_1.fmtTokens)((0, tokenSummary_1.summarizeTokens)({
+            inputTokens: entry.usage.input_tokens,
+            outputTokens: entry.usage.output_tokens,
+            cacheWriteTokens: entry.usage.cache_creation_input_tokens,
+            cacheReadTokens: entry.usage.cache_read_input_tokens,
+        }).total)} tokens incl. cache</span>`
         : '';
     const bodyParts = [];
     for (const block of entry.content) {

package/dist/report/sessionReportInputs.d.ts

@@ -10,7 +10,7 @@
  */
 import type { AggregatedMetrics } from '../aggregation/types';
 import type { SessionProviderBase } from '../providers/types';
-import type { SessionEvent } from '../types/sessionEvent';
+import type { SessionEvent, SubagentStats } from '../types/sessionEvent';
 import type { TranscriptEntry } from './types';
 export interface SessionReportInputs {
     sessionPath: string;
@@ -18,6 +18,8 @@ export interface SessionReportInputs {
     events: SessionEvent[];
     metrics: AggregatedMetrics;
     transcript: TranscriptEntry[];
+    /** The session's subagents; pass as `HtmlReportOptions.subagents` for the session total. */
+    subagents: SubagentStats[];
 }
 /** Read a session once and build the aggregator metrics and report transcript from it. */
 export declare function readSessionReportInputs(provider: SessionProviderBase, sessionPath: string): SessionReportInputs;

package/dist/report/sessionReportInputs.js

@@ -13,6 +13,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readSessionReportInputs = readSessionReportInputs;
 const EventAggregator_1 = require("../aggregation/EventAggregator");
 const sessionStats_1 = require("../sessionStats");
+const sessionTokenTotals_1 = require("../sessionTokenTotals");
 const transcriptParser_1 = require("./transcriptParser");
 /** Read a session once and build the aggregator metrics and report transcript from it. */
 function readSessionReportInputs(provider, sessionPath) {
@@ -30,5 +31,6 @@ function readSessionReportInputs(provider, sessionPath) {
         events,
         metrics: aggregator.getMetrics(),
         transcript: (0, transcriptParser_1.parseTranscriptFromEvents)(events),
+        subagents: (0, sessionTokenTotals_1.scanSessionSubagents)(provider, sessionPath),
     };
 }

package/dist/report/types.d.ts

@@ -42,4 +42,9 @@ export interface HtmlReportOptions {
     includeToolDetail?: boolean;
     /** Color theme (default: 'dark'). */
     theme?: 'dark' | 'light';
+    /**
+     * The session's subagents (`provider.scanSubagents()`). Their tokens are
+     * reported beside the main thread and added to the session total.
+     */
+    subagents?: readonly import('../types/sessionEvent').SubagentStats[];
 }

package/dist/schemas/sessionEvent.d.ts

@@ -51,8 +51,12 @@ export declare const sessionMessageSchema: z.ZodObject<{
             source: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
     }, z.core.$strip>>;
+    usageKind: z.ZodOptional<z.ZodEnum<{
+        call: "call";
+        correction: "correction";
+    }>>;
     content: z.ZodOptional<z.ZodUnknown>;
-    stop_reason: z.ZodOptional<z.ZodString>;
+    stop_reason: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
 }, z.core.$strip>;
 export declare const permissionModeSchema: z.ZodEnum<{
     default: "default";
@@ -141,8 +145,12 @@ export declare const userSessionEventSchema: z.ZodObject<{
                 source: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>;
         }, z.core.$strip>>;
+        usageKind: z.ZodOptional<z.ZodEnum<{
+            call: "call";
+            correction: "correction";
+        }>>;
         content: z.ZodOptional<z.ZodUnknown>;
-        stop_reason: z.ZodOptional<z.ZodString>;
+        stop_reason: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const assistantSessionEventSchema: z.ZodObject<{
@@ -226,8 +234,12 @@ export declare const assistantSessionEventSchema: z.ZodObject<{
                 source: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>;
         }, z.core.$strip>>;
+        usageKind: z.ZodOptional<z.ZodEnum<{
+            call: "call";
+            correction: "correction";
+        }>>;
         content: z.ZodOptional<z.ZodUnknown>;
-        stop_reason: z.ZodOptional<z.ZodString>;
+        stop_reason: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const summarySessionEventSchema: z.ZodType<SummarySessionEvent>;
@@ -312,8 +324,12 @@ export declare const systemSessionEventSchema: z.ZodObject<{
                 source: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>;
         }, z.core.$strip>>;
+        usageKind: z.ZodOptional<z.ZodEnum<{
+            call: "call";
+            correction: "correction";
+        }>>;
         content: z.ZodOptional<z.ZodUnknown>;
-        stop_reason: z.ZodOptional<z.ZodString>;
+        stop_reason: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const toolUseSessionEventSchema: z.ZodObject<{
@@ -401,8 +417,12 @@ export declare const toolUseSessionEventSchema: z.ZodObject<{
                 source: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>;
         }, z.core.$strip>>;
+        usageKind: z.ZodOptional<z.ZodEnum<{
+            call: "call";
+            correction: "correction";
+        }>>;
         content: z.ZodOptional<z.ZodUnknown>;
-        stop_reason: z.ZodOptional<z.ZodString>;
+        stop_reason: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const toolResultSessionEventSchema: z.ZodObject<{
@@ -491,8 +511,12 @@ export declare const toolResultSessionEventSchema: z.ZodObject<{
                 source: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>;
         }, z.core.$strip>>;
+        usageKind: z.ZodOptional<z.ZodEnum<{
+            call: "call";
+            correction: "correction";
+        }>>;
         content: z.ZodOptional<z.ZodUnknown>;
-        stop_reason: z.ZodOptional<z.ZodString>;
+        stop_reason: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const sessionEventSchema: z.ZodType<SessionEvent>;

package/dist/schemas/sessionEvent.js

@@ -29,8 +29,14 @@ exports.sessionMessageSchema = zod_1.z.object({
     model: zod_1.z.string().optional(),
     usage: exports.messageUsageSchema.optional(),
     normalizedUsage: usageNormalization_1.normalizedUsageSchema.optional(),
+    usageKind: zod_1.z.enum(['call', 'correction']).optional(),
     content: zod_1.z.unknown().optional(),
-    stop_reason: zod_1.z.string().optional(),
+    // Streaming lines can carry `stop_reason: null`; rejecting it dropped the
+    // whole event (text, tools, and usage), so normalize it to absent.
+    stop_reason: zod_1.z
+        .string()
+        .nullish()
+        .transform((value) => value ?? undefined),
 });
 // ── PermissionMode ──
 exports.permissionModeSchema = zod_1.z.enum([