@a5c-ai/agent-platform 5.0.1-staging.016f0b0e8119

package/dist/breakpoints/postures.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Status: NOT INTEGRATED YET
+ * Moved from @a5c-ai/babysitter-sdk.
+ * GAP-SEC-005: Approval Posture Model
+ *
+ * Defines the canonical safety ladder for action categories and provides
+ * posture resolution from breakpoint IDs.
+ *
+ * @module breakpoints/postures
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_POSTURES = void 0;
+exports.getPostureForCategory = getPostureForCategory;
+exports.resolvePostureFromBreakpointId = resolvePostureFromBreakpointId;
+/**
+ * Default postures per action category.
+ * The canonical safety ladder: read (permissive) -> write/network -> execute -> destroy/auth (locked).
+ */
+exports.DEFAULT_POSTURES = {
+    read: {
+        name: 'permissive',
+        allowAutoApprove: true,
+        minConsecutiveApprovalsForAutoN: 0,
+        requireExplicitRule: false,
+        requiredApproverLevel: 'any',
+    },
+    write: {
+        name: 'cautious',
+        allowAutoApprove: true,
+        minConsecutiveApprovalsForAutoN: 3,
+        requireExplicitRule: false,
+        requiredApproverLevel: 'any',
+    },
+    execute: {
+        name: 'guarded',
+        allowAutoApprove: true,
+        minConsecutiveApprovalsForAutoN: 5,
+        requireExplicitRule: true,
+        requiredApproverLevel: 'any',
+    },
+    destroy: {
+        name: 'locked',
+        allowAutoApprove: false,
+        minConsecutiveApprovalsForAutoN: -1,
+        requireExplicitRule: true,
+        requiredApproverLevel: 'owner',
+    },
+    network: {
+        name: 'cautious',
+        allowAutoApprove: true,
+        minConsecutiveApprovalsForAutoN: 3,
+        requireExplicitRule: false,
+        requiredApproverLevel: 'any',
+    },
+    auth: {
+        name: 'locked',
+        allowAutoApprove: false,
+        minConsecutiveApprovalsForAutoN: -1,
+        requireExplicitRule: true,
+        requiredApproverLevel: 'owner',
+    },
+};
+/**
+ * Get the posture for a category, optionally merged with overrides.
+ */
+function getPostureForCategory(category, overrides) {
+    const base = exports.DEFAULT_POSTURES[category];
+    if (!overrides)
+        return base;
+    return { ...base, ...overrides };
+}
+/**
+ * Prefix-to-category mapping for breakpoint ID namespace convention.
+ */
+const PREFIX_TO_CATEGORY = {
+    'read': 'read',
+    'write': 'write',
+    'exec': 'execute',
+    'execute': 'execute',
+    'destroy': 'destroy',
+    'delete': 'destroy',
+    'net': 'network',
+    'network': 'network',
+    'auth': 'auth',
+    'cred': 'auth',
+};
+/**
+ * Resolve an action category from a breakpoint ID's namespace prefix.
+ * Returns undefined for unknown prefixes (no posture enforcement applied).
+ *
+ * Convention: breakpointId format is `prefix.name` (e.g., `destroy.important-files`).
+ */
+function resolvePostureFromBreakpointId(breakpointId) {
+    const dotIndex = breakpointId.indexOf('.');
+    if (dotIndex === -1)
+        return undefined;
+    const prefix = breakpointId.substring(0, dotIndex);
+    return PREFIX_TO_CATEGORY[prefix];
+}

package/dist/compression/compaction.d.ts

@@ -0,0 +1,82 @@
+/**
+ * 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.
+ */
+export type CompactionStrategy = "tool-output-summarization" | "iteration-digest";
+export interface CompactionConfig {
+    enabled: boolean;
+    /** Token budget threshold that triggers auto-compaction. */
+    autoCompactThreshold: number;
+    /** Strategies to apply, in order. */
+    strategies: CompactionStrategy[];
+    /** Maximum recent iterations to keep uncompacted. */
+    keepRecentIterations: number;
+    /** Target token reduction ratio for tool output summarization (0-1). */
+    toolOutputTargetReduction: number;
+}
+export interface CompactionResult {
+    strategy: CompactionStrategy;
+    tokensBefore: number;
+    tokensAfter: number;
+    itemsCompacted: number;
+    compactedAt: string;
+}
+export interface IterationDigest {
+    iteration: number;
+    runId: string;
+    summary: string;
+    resolvedEffects: string[];
+    durationSeconds: number;
+    timestamp: string;
+}
+export interface ToolOutputSummary {
+    /** Relative path from runsDir: runId/tasks/effectId/file */
+    relativePath: string;
+    /** Truncated/summarized content */
+    summary: string;
+    /** Original token count */
+    originalTokens: number;
+}
+export interface CompactionState {
+    operations: CompactionResult[];
+    iterationDigests: IterationDigest[];
+    toolOutputSummaries: ToolOutputSummary[];
+    totalTokensSaved: number;
+}
+interface JournalEvent {
+    type: string;
+    recordedAt: string;
+    data?: Record<string, unknown>;
+}
+export declare const DEFAULT_COMPACTION_CONFIG: CompactionConfig;
+export declare function getCompactionStatePath(stateDir: string, sessionId: string): string;
+export declare function getCompactionState(stateDir: string, sessionId: string): Promise<CompactionState>;
+/**
+ * Check whether auto-compaction should trigger.
+ */
+export declare function shouldAutoCompact(estimatedTokens: number, config: CompactionConfig): boolean;
+/**
+ * Build a digest from a set of journal events belonging to one iteration.
+ * Pure function.
+ */
+export declare function buildIterationDigest(runId: string, iteration: number, events: JournalEvent[]): IterationDigest;
+/**
+ * Run compaction strategies on a session.
+ * Reads journal/tasks as needed but only writes to the overlay file — never
+ * modifies originals.
+ */
+export declare function compactSession(stateDir: string, sessionId: string, runsDir: string, config?: CompactionConfig): Promise<CompactionResult[]>;
+/**
+ * Render iteration digests as markdown for prompt injection.
+ */
+export declare function renderCompactedHistory(state: CompactionState): string;
+export {};
+//# sourceMappingURL=compaction.d.ts.map

package/dist/compression/compaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compaction.d.ts","sourceRoot":"","sources":["../../src/compression/compaction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AASH,MAAM,MAAM,kBAAkB,GAC1B,2BAA2B,GAC3B,kBAAkB,CAAC;AAEvB,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,4DAA4D;IAC5D,oBAAoB,EAAE,MAAM,CAAC;IAC7B,qCAAqC;IACrC,UAAU,EAAE,kBAAkB,EAAE,CAAC;IACjC,qDAAqD;IACrD,oBAAoB,EAAE,MAAM,CAAC;IAC7B,wEAAwE;IACxE,yBAAyB,EAAE,MAAM,CAAC;CACnC;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,4DAA4D;IAC5D,YAAY,EAAE,MAAM,CAAC;IACrB,mCAAmC;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,2BAA2B;IAC3B,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,gBAAgB,EAAE,eAAe,EAAE,CAAC;IACpC,mBAAmB,EAAE,iBAAiB,EAAE,CAAC;IACzC,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAMD,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAMD,eAAO,MAAM,yBAAyB,EAAE,gBAMvC,CAAC;AAiDF,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAElF;AAED,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAEtG;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,eAAe,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAG5F;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,YAAY,EAAE,GACrB,eAAe,CAgCjB;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,MAAM,GAAE,gBAA4C,GACnD,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAkB7B;AAwID;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAQrE"}

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"}