sidekick-shared 0.27.2 → 0.27.4

package/dist/parsers/subagentScanner.js

@@ -42,16 +42,42 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAgentMeta = readAgentMeta;
 exports.scanSubagentDir = scanSubagentDir;
 exports.handleTaskUpdate = handleTaskUpdate;
 exports.extractTaskInfo = extractTaskInfo;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const claudeUsageDedupe_1 = require("../usage/claudeUsageDedupe");
+const subagentUsage_1 = require("../usage/subagentUsage");
+const subagentStatsCache_1 = require("./subagentStatsCache");
 /**
  * Pattern for matching subagent JSONL files.
  * Files are named like: agent-<hash>.jsonl
  */
 const AGENT_FILE_PATTERN = /^agent-(.+)\.jsonl$/;
+/**
+ * Reads `agent-<id>.meta.json` (written by Claude Code next to the transcript)
+ * for the spawn's agent type and description. Missing or malformed files
+ * yield an empty object.
+ */
+function readAgentMeta(agentFilePath) {
+    try {
+        const metaPath = agentFilePath.replace(/\.jsonl$/, '.meta.json');
+        const parsed = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+        return {
+            ...(typeof parsed.agentType === 'string' && parsed.agentType
+                ? { agentType: parsed.agentType }
+                : {}),
+            ...(typeof parsed.description === 'string' && parsed.description
+                ? { description: parsed.description }
+                : {}),
+        };
+    }
+    catch {
+        return {};
+    }
+}
 /** Task-related tool names */
 const TASK_TOOLS = ['TaskCreate', 'TaskUpdate', 'TaskGet', 'TaskList'];
 /**
@@ -118,7 +144,7 @@ function scanSubagentDir(sessionDir, sessionId, logger, skipFiles = new Set()) {
             }
             const agentId = match[1];
             const filePath = path.join(subagentsDir, file);
-            const agentStats = parseAgentFile(filePath, agentId, log);
+            const agentStats = (0, subagentStatsCache_1.cachedSubagentStats)(filePath, () => parseAgentFile(filePath, agentId, log));
             if (agentStats) {
                 log(`[SubagentScanner] Agent ${agentId}: ${agentStats.toolCalls.length} tool calls`);
                 results.push(agentStats);
@@ -150,8 +176,8 @@ function parseAgentFile(filePath, agentId, log) {
         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;
         // Task tracking state
@@ -168,12 +194,11 @@ function parseAgentFile(filePath, agentId, log) {
                 if (!startTime)
                     startTime = eventTimestamp;
                 endTime = eventTimestamp;
-                // Extract token usage from assistant messages
-                if (event.type === 'assistant' && event.message?.usage) {
-                    const usage = event.message.usage;
-                    inputTokens += usage.input_tokens || 0;
-                    outputTokens += usage.output_tokens || 0;
-                }
+                // Extract token usage from assistant messages. Split lines of one
+                // response repeat its usage, so count each response once.
+                const usage = (0, claudeUsageDedupe_1.dedupedRawClaudeUsage)(event, usageDeduper);
+                if (usage)
+                    (0, subagentUsage_1.addUsageToSubagent)(tokens, usage);
                 // Extract agent type and description from Task tool invocation
                 // This appears in the parent session, but we can also look for it
                 // in the first system message or context
@@ -269,8 +294,12 @@ function parseAgentFile(filePath, agentId, log) {
                 // Skip malformed lines
             }
         }
+        // Claude Code writes the spawn's type and description beside the transcript.
+        const meta = readAgentMeta(filePath);
+        agentType = meta.agentType ?? agentType;
+        description = meta.description ?? description;
         // If we found any tool calls, return the stats
-        if (toolCalls.length > 0 || agentType || description || inputTokens > 0) {
+        if (toolCalls.length > 0 || agentType || description || (tokens.totalTokens ?? 0) > 0) {
             const durationMs = startTime && endTime ? endTime.getTime() - startTime.getTime() : undefined;
             return {
                 agentId,
@@ -278,8 +307,12 @@ function parseAgentFile(filePath, agentId, log) {
                 description,
                 toolCalls,
                 taskState: taskState.tasks.size > 0 ? taskState : undefined,
-                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/parsers/subagentStatsCache.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Memoizes per-transcript subagent stats by file size and mtime.
+ *
+ * Dashboards rescan a session's subagents on a timer, and one parent can own
+ * a hundred subagent transcripts of several MB each. An unchanged transcript
+ * now costs one `stat` instead of a full parse. Callers treat the returned
+ * stats as read-only.
+ *
+ * Node-only: stats files.
+ *
+ * @module parsers/subagentStatsCache
+ */
+import type { SubagentStats } from '../types/sessionEvent';
+/** Stats for one subagent transcript, parsed again only when the file changed. */
+export declare function cachedSubagentStats(filePath: string, compute: () => SubagentStats | null): SubagentStats | null;
+/** @internal Test hook. */
+export declare function clearSubagentStatsCache(): void;

package/dist/parsers/subagentStatsCache.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Memoizes per-transcript subagent stats by file size and mtime.
+ *
+ * Dashboards rescan a session's subagents on a timer, and one parent can own
+ * a hundred subagent transcripts of several MB each. An unchanged transcript
+ * now costs one `stat` instead of a full parse. Callers treat the returned
+ * stats as read-only.
+ *
+ * Node-only: stats files.
+ *
+ * @module parsers/subagentStatsCache
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cachedSubagentStats = cachedSubagentStats;
+exports.clearSubagentStatsCache = clearSubagentStatsCache;
+const fs = __importStar(require("fs"));
+const MAX_ENTRIES = 1024;
+const cache = new Map();
+/** Stats for one subagent transcript, parsed again only when the file changed. */
+function cachedSubagentStats(filePath, compute) {
+    let stat;
+    try {
+        stat = fs.statSync(filePath);
+    }
+    catch {
+        cache.delete(filePath);
+        return compute();
+    }
+    const hit = cache.get(filePath);
+    if (hit && hit.size === stat.size && hit.mtimeMs === stat.mtimeMs) {
+        cache.delete(filePath);
+        cache.set(filePath, hit);
+        return hit.stats;
+    }
+    const stats = compute();
+    cache.delete(filePath);
+    cache.set(filePath, { size: stat.size, mtimeMs: stat.mtimeMs, stats });
+    if (cache.size > MAX_ENTRIES) {
+        const oldest = cache.keys().next().value;
+        if (oldest !== undefined)
+            cache.delete(oldest);
+    }
+    return stats;
+}
+/** @internal Test hook. */
+function clearSubagentStatsCache() {
+    cache.clear();
+}

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,