@a5c-ai/agent-platform 5.0.1-staging.b436b3b3e611

package/dist/compression/compaction.js

@@ -0,0 +1,310 @@
+"use strict";
+/**
+ * Status: NOT INTEGRATED YET
+ * Moved from @a5c-ai/babysitter-sdk.
+ * GAP-PERF-002: Session Compaction.
+ *
+ * Summarizes and condenses orchestration history to prevent context window
+ * overflow during long runs. Multiple strategies with auto-triggering
+ * based on token budget thresholds.
+ *
+ * Compacted data is stored as overlays — original journals and task artifacts
+ * are never modified.
+ */
+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.DEFAULT_COMPACTION_CONFIG = void 0;
+exports.getCompactionStatePath = getCompactionStatePath;
+exports.getCompactionState = getCompactionState;
+exports.shouldAutoCompact = shouldAutoCompact;
+exports.buildIterationDigest = buildIterationDigest;
+exports.compactSession = compactSession;
+exports.renderCompactedHistory = renderCompactedHistory;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+exports.DEFAULT_COMPACTION_CONFIG = {
+    enabled: true,
+    autoCompactThreshold: 80_000,
+    strategies: ["tool-output-summarization", "iteration-digest"],
+    keepRecentIterations: 3,
+    toolOutputTargetReduction: 0.6,
+};
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function emptyCompactionState() {
+    return { operations: [], iterationDigests: [], toolOutputSummaries: [], totalTokensSaved: 0 };
+}
+async function readRaw(filePath) {
+    let raw;
+    try {
+        raw = await node_fs_1.promises.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT")
+            return emptyCompactionState();
+        return emptyCompactionState();
+    }
+    try {
+        const data = JSON.parse(raw);
+        return {
+            operations: Array.isArray(data.operations) ? data.operations : [],
+            iterationDigests: Array.isArray(data.iterationDigests) ? data.iterationDigests : [],
+            toolOutputSummaries: Array.isArray(data.toolOutputSummaries) ? data.toolOutputSummaries : [],
+            totalTokensSaved: typeof data.totalTokensSaved === "number" ? data.totalTokensSaved : 0,
+        };
+    }
+    catch {
+        return emptyCompactionState();
+    }
+}
+async function writeRaw(filePath, data) {
+    const dir = path.dirname(filePath);
+    const tempPath = `${filePath}.tmp.${process.pid}`;
+    await node_fs_1.promises.mkdir(dir, { recursive: true });
+    await node_fs_1.promises.writeFile(tempPath, JSON.stringify(data, null, 2), "utf8");
+    await node_fs_1.promises.rename(tempPath, filePath);
+}
+/** Rough token estimate: ~4 chars per token. */
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+function getCompactionStatePath(stateDir, sessionId) {
+    return path.join(stateDir, `${sessionId}.compaction.json`);
+}
+async function getCompactionState(stateDir, sessionId) {
+    return readRaw(getCompactionStatePath(stateDir, sessionId));
+}
+/**
+ * Check whether auto-compaction should trigger.
+ */
+function shouldAutoCompact(estimatedTokens, config) {
+    if (!config.enabled)
+        return false;
+    return estimatedTokens > config.autoCompactThreshold;
+}
+/**
+ * Build a digest from a set of journal events belonging to one iteration.
+ * Pure function.
+ */
+function buildIterationDigest(runId, iteration, events) {
+    const resolvedEffects = [];
+    let earliestAt = "";
+    let latestAt = "";
+    for (const ev of events) {
+        if (!earliestAt || ev.recordedAt < earliestAt)
+            earliestAt = ev.recordedAt;
+        if (!latestAt || ev.recordedAt > latestAt)
+            latestAt = ev.recordedAt;
+        if (ev.type === "EFFECT_RESOLVED" && ev.data) {
+            const effectId = ev.data.effectId;
+            if (effectId)
+                resolvedEffects.push(effectId);
+        }
+    }
+    const durationSeconds = earliestAt && latestAt
+        ? (new Date(latestAt).getTime() - new Date(earliestAt).getTime()) / 1000
+        : 0;
+    const effectCount = resolvedEffects.length;
+    const eventTypes = [...new Set(events.map((e) => e.type))];
+    const summary = `Iteration ${iteration}: ${effectCount} effect(s) resolved, events: ${eventTypes.join(", ")}`;
+    return {
+        iteration,
+        runId,
+        summary,
+        resolvedEffects,
+        durationSeconds,
+        timestamp: latestAt || new Date().toISOString(),
+    };
+}
+/**
+ * Run compaction strategies on a session.
+ * Reads journal/tasks as needed but only writes to the overlay file — never
+ * modifies originals.
+ */
+async function compactSession(stateDir, sessionId, runsDir, config = exports.DEFAULT_COMPACTION_CONFIG) {
+    if (!config.enabled)
+        return [];
+    const overlayPath = getCompactionStatePath(stateDir, sessionId);
+    const state = await readRaw(overlayPath);
+    const results = [];
+    for (const strategy of config.strategies) {
+        const result = await applyStrategy(strategy, runsDir, config, state);
+        if (result) {
+            state.operations.push(result);
+            state.totalTokensSaved += result.tokensBefore - result.tokensAfter;
+            results.push(result);
+        }
+    }
+    await writeRaw(overlayPath, state);
+    return results;
+}
+async function applyStrategy(strategy, runsDir, config, state) {
+    const now = new Date().toISOString();
+    if (strategy === "iteration-digest") {
+        // Scan run directories for journal files, build digests for old iterations
+        const existingDigestIterations = new Set(state.iterationDigests.map((d) => `${d.runId}:${d.iteration}`));
+        let itemsCompacted = 0;
+        let tokensBefore = 0;
+        let tokensAfter = 0;
+        let runDirs;
+        try {
+            const entries = await node_fs_1.promises.readdir(runsDir, { withFileTypes: true });
+            runDirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+        }
+        catch {
+            return undefined;
+        }
+        for (const runDir of runDirs) {
+            const journalDir = path.join(runsDir, runDir, "journal");
+            let files;
+            try {
+                files = await node_fs_1.promises.readdir(journalDir);
+            }
+            catch {
+                continue;
+            }
+            // Group events by iteration (heuristic: each EFFECT_REQUESTED starts new iteration group)
+            const events = [];
+            for (const file of files.sort()) {
+                if (!file.endsWith(".json"))
+                    continue;
+                try {
+                    const raw = await node_fs_1.promises.readFile(path.join(journalDir, file), "utf8");
+                    events.push(JSON.parse(raw));
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (events.length === 0)
+                continue;
+            // Simple iteration grouping: split at RUN_CREATED or sequential grouping
+            const iterationSize = Math.max(1, Math.ceil(events.length / Math.max(1, config.keepRecentIterations + 1)));
+            const totalGroups = Math.ceil(events.length / iterationSize);
+            const compactableGroups = Math.max(0, totalGroups - config.keepRecentIterations);
+            for (let i = 0; i < compactableGroups; i++) {
+                const key = `${runDir}:${i + 1}`;
+                if (existingDigestIterations.has(key))
+                    continue;
+                const groupEvents = events.slice(i * iterationSize, (i + 1) * iterationSize);
+                const beforeTokens = estimateTokens(JSON.stringify(groupEvents));
+                const digest = buildIterationDigest(runDir, i + 1, groupEvents);
+                const afterTokens = estimateTokens(JSON.stringify(digest));
+                state.iterationDigests.push(digest);
+                tokensBefore += beforeTokens;
+                tokensAfter += afterTokens;
+                itemsCompacted++;
+            }
+        }
+        if (itemsCompacted === 0)
+            return undefined;
+        return { strategy, tokensBefore, tokensAfter, itemsCompacted, compactedAt: now };
+    }
+    if (strategy === "tool-output-summarization") {
+        // Scan task directories for large stdout/stderr, create summarized overlays
+        let itemsCompacted = 0;
+        let tokensBefore = 0;
+        let tokensAfter = 0;
+        let runDirs;
+        try {
+            const entries = await node_fs_1.promises.readdir(runsDir, { withFileTypes: true });
+            runDirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+        }
+        catch {
+            return undefined;
+        }
+        for (const runDir of runDirs) {
+            const tasksDir = path.join(runsDir, runDir, "tasks");
+            let taskDirs;
+            try {
+                const entries = await node_fs_1.promises.readdir(tasksDir, { withFileTypes: true });
+                taskDirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+            }
+            catch {
+                continue;
+            }
+            for (const taskDir of taskDirs) {
+                for (const file of ["stdout.txt", "stderr.txt"]) {
+                    const filePath = path.join(tasksDir, taskDir, file);
+                    try {
+                        const content = await node_fs_1.promises.readFile(filePath, "utf8");
+                        const beforeTokens = estimateTokens(content);
+                        if (beforeTokens < 200)
+                            continue; // Skip small outputs
+                        const relativePath = `${runDir}/tasks/${taskDir}/${file}`;
+                        // Skip if already summarized
+                        if (state.toolOutputSummaries.some((s) => s.relativePath === relativePath))
+                            continue;
+                        const targetLength = Math.ceil(content.length * (1 - config.toolOutputTargetReduction));
+                        const truncated = content.slice(0, targetLength) + "\n... [compacted]";
+                        const afterTokens = estimateTokens(truncated);
+                        state.toolOutputSummaries.push({
+                            relativePath,
+                            summary: truncated,
+                            originalTokens: beforeTokens,
+                        });
+                        tokensBefore += beforeTokens;
+                        tokensAfter += afterTokens;
+                        itemsCompacted++;
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
+        }
+        if (itemsCompacted === 0)
+            return undefined;
+        return { strategy, tokensBefore, tokensAfter, itemsCompacted, compactedAt: now };
+    }
+    return undefined;
+}
+/**
+ * Render iteration digests as markdown for prompt injection.
+ */
+function renderCompactedHistory(state) {
+    if (state.iterationDigests.length === 0)
+        return "";
+    const lines = state.iterationDigests.map((d) => `- **Iter ${d.iteration}** (${d.runId}): ${d.summary} [${d.durationSeconds.toFixed(1)}s]`);
+    return `## Compacted History\n\n${lines.join("\n")}\n\n_${state.totalTokensSaved} tokens saved across ${state.operations.length} compaction(s)._`;
+}

package/dist/cost/claudeCodeParser.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Claude Code JSONL session file parser for cost data collection.
+ *
+ * Parses Claude Code session JSONL files (main session and subagent files)
+ * to extract token usage data and compute costs. Each assistant message with
+ * a `usage` block becomes a {@link CostEventData} entry.
+ *
+ * JSONL format (one JSON object per line):
+ * ```json
+ * {
+ *   "type": "assistant",
+ *   "message": {
+ *     "model": "claude-opus-4-6",
+ *     "usage": {
+ *       "input_tokens": 3,
+ *       "cache_creation_input_tokens": 26928,
+ *       "cache_read_input_tokens": 0,
+ *       "cache_creation": { "ephemeral_5m_input_tokens": 0, "ephemeral_1h_input_tokens": 26928 },
+ *       "output_tokens": 28,
+ *       "service_tier": "standard"
+ *     }
+ *   },
+ *   "timestamp": "2026-04-05T..."
+ * }
+ * ```
+ */
+import type { CostEventData, ModelCostStats } from "./types";
+/**
+ * Parse a single Claude Code session JSONL file into cost events.
+ *
+ * Reads the file, splits by newline, and for each line that represents an
+ * assistant message with usage data, extracts token counts and computes
+ * the USD cost using the extended pricing model.
+ *
+ * @param sessionJsonlPath - Absolute path to the `.jsonl` file.
+ * @returns Array of cost events extracted from assistant messages.
+ */
+export declare function parseClaudeCodeSession(sessionJsonlPath: string): Promise<CostEventData[]>;
+/**
+ * Parse a Claude Code session JSONL file and all associated subagent files.
+ *
+ * Subagent files live at `<sessionDir>/subagents/agent-*.jsonl` where
+ * `<sessionDir>` is derived by stripping the `.jsonl` extension from the
+ * main session file path.
+ *
+ * @param sessionJsonlPath - Absolute path to the main session `.jsonl` file.
+ * @returns Merged array of cost events from the main session and all subagents.
+ */
+export declare function parseClaudeCodeSessionWithSubagents(sessionJsonlPath: string): Promise<CostEventData[]>;
+/** Aggregated usage summary returned by {@link aggregateUsageData}. */
+export interface AggregatedUsage {
+    /** Total number of cost events. */
+    eventCount: number;
+    /** Total base input tokens across all events. */
+    totalInputTokens: number;
+    /** Total output tokens across all events. */
+    totalOutputTokens: number;
+    /** Total cache-creation tokens (top-level) across all events. */
+    totalCacheCreationTokens: number;
+    /** Total cache-read tokens across all events. */
+    totalCacheReadTokens: number;
+    /** Total 5-minute cache-creation tokens. */
+    totalCacheCreation5mTokens: number;
+    /** Total 1-hour cache-creation tokens. */
+    totalCacheCreation1hTokens: number;
+    /** Total computed cost in USD. */
+    totalCostUsd: number;
+    /** Per-model breakdown of usage statistics. */
+    byModel: Record<string, ModelCostStats>;
+}
+/**
+ * Aggregate usage data across an array of cost events.
+ *
+ * Sums token counts and costs, producing both overall totals and a
+ * per-model breakdown.
+ *
+ * @param events - Array of cost events (e.g. from {@link parseClaudeCodeSessionWithSubagents}).
+ * @returns Aggregated usage summary with per-model breakdown.
+ */
+export declare function aggregateUsageData(events: CostEventData[]): AggregatedUsage;
+//# sourceMappingURL=claudeCodeParser.d.ts.map

package/dist/cost/claudeCodeParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claudeCodeParser.d.ts","sourceRoot":"","sources":["../../src/cost/claudeCodeParser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAqC7D;;;;;;;;;GASG;AACH,wBAAsB,sBAAsB,CAC1C,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,aAAa,EAAE,CAAC,CA+D1B;AAMD;;;;;;;;;GASG;AACH,wBAAsB,mCAAmC,CACvD,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,aAAa,EAAE,CAAC,CA+B1B;AAMD,uEAAuE;AACvE,MAAM,WAAW,eAAe;IAC9B,mCAAmC;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,iDAAiD;IACjD,gBAAgB,EAAE,MAAM,CAAC;IACzB,6CAA6C;IAC7C,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iEAAiE;IACjE,wBAAwB,EAAE,MAAM,CAAC;IACjC,iDAAiD;IACjD,oBAAoB,EAAE,MAAM,CAAC;IAC7B,4CAA4C;IAC5C,0BAA0B,EAAE,MAAM,CAAC;IACnC,0CAA0C;IAC1C,0BAA0B,EAAE,MAAM,CAAC;IACnC,kCAAkC;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;CACzC;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,eAAe,CAqD3E"}

package/dist/cost/claudeCodeParser.js

@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * Claude Code JSONL session file parser for cost data collection.
+ *
+ * Parses Claude Code session JSONL files (main session and subagent files)
+ * to extract token usage data and compute costs. Each assistant message with
+ * a `usage` block becomes a {@link CostEventData} entry.
+ *
+ * JSONL format (one JSON object per line):
+ * ```json
+ * {
+ *   "type": "assistant",
+ *   "message": {
+ *     "model": "claude-opus-4-6",
+ *     "usage": {
+ *       "input_tokens": 3,
+ *       "cache_creation_input_tokens": 26928,
+ *       "cache_read_input_tokens": 0,
+ *       "cache_creation": { "ephemeral_5m_input_tokens": 0, "ephemeral_1h_input_tokens": 26928 },
+ *       "output_tokens": 28,
+ *       "service_tier": "standard"
+ *     }
+ *   },
+ *   "timestamp": "2026-04-05T..."
+ * }
+ * ```
+ */
+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.parseClaudeCodeSession = parseClaudeCodeSession;
+exports.parseClaudeCodeSessionWithSubagents = parseClaudeCodeSessionWithSubagents;
+exports.aggregateUsageData = aggregateUsageData;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const types_1 = require("./types");
+// ============================================================================
+// Single-file parser
+// ============================================================================
+/**
+ * Parse a single Claude Code session JSONL file into cost events.
+ *
+ * Reads the file, splits by newline, and for each line that represents an
+ * assistant message with usage data, extracts token counts and computes
+ * the USD cost using the extended pricing model.
+ *
+ * @param sessionJsonlPath - Absolute path to the `.jsonl` file.
+ * @returns Array of cost events extracted from assistant messages.
+ */
+async function parseClaudeCodeSession(sessionJsonlPath) {
+    let content;
+    try {
+        content = await node_fs_1.promises.readFile(sessionJsonlPath, "utf-8");
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === "ENOENT")
+            return [];
+        throw err;
+    }
+    const lines = content.split("\n");
+    const events = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(trimmed);
+        }
+        catch {
+            // Malformed line — skip silently.
+            continue;
+        }
+        if (entry.type !== "assistant")
+            continue;
+        const usage = entry.message?.usage;
+        if (!usage)
+            continue;
+        const model = entry.message?.model ?? "unknown";
+        const inputTokens = usage.input_tokens ?? 0;
+        const outputTokens = usage.output_tokens ?? 0;
+        const cacheCreationTokens = usage.cache_creation_input_tokens ?? 0;
+        const cacheReadTokens = usage.cache_read_input_tokens ?? 0;
+        const cacheCreation5mTokens = usage.cache_creation?.ephemeral_5m_input_tokens ?? 0;
+        const cacheCreation1hTokens = usage.cache_creation?.ephemeral_1h_input_tokens ?? 0;
+        const costUsd = (0, types_1.calculateCostUsdExtended)(model, inputTokens, outputTokens, cacheCreation5mTokens, cacheCreation1hTokens, cacheReadTokens);
+        events.push({
+            model,
+            inputTokens,
+            outputTokens,
+            cacheCreationTokens,
+            cacheReadTokens,
+            cacheCreation5mTokens,
+            cacheCreation1hTokens,
+            serviceTier: usage.service_tier,
+            costUsd: costUsd ?? undefined,
+            timestamp: entry.timestamp,
+        });
+    }
+    return events;
+}
+// ============================================================================
+// Session + subagent parser
+// ============================================================================
+/**
+ * Parse a Claude Code session JSONL file and all associated subagent files.
+ *
+ * Subagent files live at `<sessionDir>/subagents/agent-*.jsonl` where
+ * `<sessionDir>` is derived by stripping the `.jsonl` extension from the
+ * main session file path.
+ *
+ * @param sessionJsonlPath - Absolute path to the main session `.jsonl` file.
+ * @returns Merged array of cost events from the main session and all subagents.
+ */
+async function parseClaudeCodeSessionWithSubagents(sessionJsonlPath) {
+    // Parse main session file.
+    const mainEvents = await parseClaudeCodeSession(sessionJsonlPath);
+    // Derive the session directory (same name without .jsonl extension).
+    const sessionDir = sessionJsonlPath.replace(/\.jsonl$/, "");
+    const subagentsDir = path.join(sessionDir, "subagents");
+    let subagentFiles;
+    try {
+        const entries = await node_fs_1.promises.readdir(subagentsDir);
+        subagentFiles = entries
+            .filter((f) => f.startsWith("agent-") && f.endsWith(".jsonl"))
+            .map((f) => path.join(subagentsDir, f));
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === "ENOENT")
+            return mainEvents;
+        throw err;
+    }
+    // Parse all subagent files and merge.
+    const subagentResults = await Promise.all(subagentFiles.map((f) => parseClaudeCodeSession(f)));
+    const allEvents = [...mainEvents];
+    for (const sub of subagentResults) {
+        allEvents.push(...sub);
+    }
+    return allEvents;
+}
+/**
+ * Aggregate usage data across an array of cost events.
+ *
+ * Sums token counts and costs, producing both overall totals and a
+ * per-model breakdown.
+ *
+ * @param events - Array of cost events (e.g. from {@link parseClaudeCodeSessionWithSubagents}).
+ * @returns Aggregated usage summary with per-model breakdown.
+ */
+function aggregateUsageData(events) {
+    const result = {
+        eventCount: 0,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalCacheCreationTokens: 0,
+        totalCacheReadTokens: 0,
+        totalCacheCreation5mTokens: 0,
+        totalCacheCreation1hTokens: 0,
+        totalCostUsd: 0,
+        byModel: {},
+    };
+    for (const event of events) {
+        result.eventCount += 1;
+        result.totalInputTokens += event.inputTokens;
+        result.totalOutputTokens += event.outputTokens;
+        result.totalCacheCreationTokens += event.cacheCreationTokens;
+        result.totalCacheReadTokens += event.cacheReadTokens;
+        result.totalCacheCreation5mTokens += event.cacheCreation5mTokens;
+        result.totalCacheCreation1hTokens += event.cacheCreation1hTokens;
+        result.totalCostUsd += event.costUsd ?? 0;
+        // Per-model breakdown.
+        const model = event.model ?? "unknown";
+        if (!result.byModel[model]) {
+            result.byModel[model] = {
+                model,
+                eventCount: 0,
+                inputTokens: 0,
+                outputTokens: 0,
+                cacheCreationTokens: 0,
+                cacheReadTokens: 0,
+                costUsd: 0,
+            };
+        }
+        const ms = result.byModel[model];
+        ms.eventCount += 1;
+        ms.inputTokens += event.inputTokens;
+        ms.outputTokens += event.outputTokens;
+        ms.cacheCreationTokens += event.cacheCreationTokens;
+        ms.cacheReadTokens += event.cacheReadTokens;
+        ms.costUsd += event.costUsd ?? 0;
+    }
+    // Round totals to 6 decimal places to avoid floating-point drift.
+    result.totalCostUsd =
+        Math.round(result.totalCostUsd * 1_000_000) / 1_000_000;
+    for (const ms of Object.values(result.byModel)) {
+        ms.costUsd = Math.round(ms.costUsd * 1_000_000) / 1_000_000;
+    }
+    return result;
+}

package/dist/cost/collector.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Cost data collector for Babysitter runs.
+ *
+ * Bridges the Claude Code JSONL parser with the run journal: parses a
+ * session file (including subagent files), then writes COST_TRACKED events
+ * to the run's journal for later aggregation and reporting.
+ */
+/**
+ * Parse a Claude Code session (main + subagents) and write COST_TRACKED
+ * events into the run journal.
+ *
+ * Each assistant message with usage data becomes a separate journal event,
+ * preserving the full token breakdown for fine-grained cost analysis.
+ *
+ * @param runDir - Absolute path to the run directory (e.g. `.a5c/runs/<runId>`).
+ * @param sessionJsonlPath - Absolute path to the main session `.jsonl` file.
+ * @returns The number of COST_TRACKED events written to the journal.
+ */
+export declare function collectCostDataForRun(runDir: string, sessionJsonlPath: string): Promise<number>;
+/**
+ * Resolve the Claude Code projects directory path for a given session ID.
+ *
+ * Claude Code stores session JSONL files at:
+ * ```
+ * ~/.claude/projects/<project-slug>/<sessionId>.jsonl
+ * ```
+ *
+ * Since we don't always know the project slug, this function returns the
+ * base Claude Code projects directory. The caller can then search for the
+ * session file within the project subdirectories.
+ *
+ * If a workspace path is provided, the project slug is derived using Claude
+ * Code's path-encoding convention (forward slashes and colons replaced with
+ * dashes, prefixed with the drive letter on Windows).
+ *
+ * @param sessionId - The Claude Code session UUID.
+ * @param workspacePath - Optional absolute workspace path to derive the project slug.
+ * @returns Absolute path to the session `.jsonl` file (when workspace is
+ *   provided) or the Claude Code projects directory (when workspace is omitted).
+ */
+export declare function resolveClaudeCodeSessionDir(sessionId: string, workspacePath?: string): string;
+//# sourceMappingURL=collector.d.ts.map

package/dist/cost/collector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collector.d.ts","sourceRoot":"","sources":["../../src/cost/collector.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAQH;;;;;;;;;;GAUG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,MAAM,EACd,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,MAAM,CAAC,CAWjB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,MAAM,EACjB,aAAa,CAAC,EAAE,MAAM,GACrB,MAAM,CAkBR"}