@juspay/neurolink 11.18.5 → 11.20.0

package/dist/index.d.ts

@@ -445,3 +445,4 @@ export { TripwireEvaluator, createDefaultTripwireEvaluator, commonTripwires, } f
 export { Agent } from "./agent/agent.js";
 export { AgentNetwork } from "./agent/agentNetwork.js";
 export { AgentCoordinator, TaskDistributor, MessageBus, NetworkOrchestrator, NetworkTopology, TopologyBuilder, } from "./agent/index.js";
+export { createLocalUsageReader, getLocalUsageDescriptors, getRegisteredLocalUsageCliIds, readAllLocalUsage, registerLocalUsageReader, } from "./localUsage/index.js";

package/dist/index.js

@@ -745,3 +745,10 @@ AgentCoordinator, TaskDistributor,
 MessageBus, 
 // Orchestration
 NetworkOrchestrator, NetworkTopology, TopologyBuilder, } from "./agent/index.js";
+// ============================================================================
+// Local usage exports
+// ============================================================================
+// Token spend read from each CLI's own session logs, rather than from proxy
+// traffic. Exported because the proxy's ledger only sees CLIs that route
+// through it; this covers the rest, and covers history predating the proxy.
+export { createLocalUsageReader, getLocalUsageDescriptors, getRegisteredLocalUsageCliIds, readAllLocalUsage, registerLocalUsageReader, } from "./localUsage/index.js";

package/dist/localUsage/claudeCodeReader.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Reads token usage out of Claude Code's own session transcripts.
+ *
+ * Layout, confirmed on a real machine rather than from documentation:
+ * `~/.claude/projects/<sanitized-cwd>/<sessionId>.jsonl`, where the sanitized
+ * cwd is the absolute working-directory path with every `/` replaced by `-`.
+ *
+ * The load-bearing detail is that top-level session transcripts are a tiny
+ * minority of the files. On the machine this was written against, 17,439
+ * transcripts totalling 9.7 GB broke down as roughly 103 top-level sessions
+ * against 17,116 subagent-task transcripts nested under
+ * `<sessionId>/subagents/`. A reader that globbed only `<project>/*.jsonl`
+ * would miss essentially all of a subagent-heavy user's real spend, so this
+ * one recurses.
+ *
+ * The files are not homogeneous message streams. A single 14,747-line
+ * transcript carried eleven distinct `type` values — `assistant`, `user`,
+ * `attachment`, `pr-link`, `last-prompt`, `mode`, `permission-mode`,
+ * `queue-operation`, `system`, `file-history-delta`, `file-history-snapshot` —
+ * several of which have no `message` key at all. Every one of its 6,028
+ * `type: "assistant"` lines carried a `message.usage` object, so that filter is
+ * safe, but everything else must be skipped rather than treated as malformed.
+ */
+import type { LocalUsageReader } from "../types/index.js";
+export declare function createClaudeCodeReader(): Promise<LocalUsageReader>;

package/dist/localUsage/claudeCodeReader.js

@@ -0,0 +1,222 @@
+/**
+ * Reads token usage out of Claude Code's own session transcripts.
+ *
+ * Layout, confirmed on a real machine rather than from documentation:
+ * `~/.claude/projects/<sanitized-cwd>/<sessionId>.jsonl`, where the sanitized
+ * cwd is the absolute working-directory path with every `/` replaced by `-`.
+ *
+ * The load-bearing detail is that top-level session transcripts are a tiny
+ * minority of the files. On the machine this was written against, 17,439
+ * transcripts totalling 9.7 GB broke down as roughly 103 top-level sessions
+ * against 17,116 subagent-task transcripts nested under
+ * `<sessionId>/subagents/`. A reader that globbed only `<project>/*.jsonl`
+ * would miss essentially all of a subagent-heavy user's real spend, so this
+ * one recurses.
+ *
+ * The files are not homogeneous message streams. A single 14,747-line
+ * transcript carried eleven distinct `type` values — `assistant`, `user`,
+ * `attachment`, `pr-link`, `last-prompt`, `mode`, `permission-mode`,
+ * `queue-operation`, `system`, `file-history-delta`, `file-history-snapshot` —
+ * several of which have no `message` key at all. Every one of its 6,028
+ * `type: "assistant"` lines carried a `message.usage` object, so that filter is
+ * safe, but everything else must be skipped rather than treated as malformed.
+ */
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import { readdir, stat } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { calculateCost, hasPricing } from "../utils/pricing.js";
+const CLI_ID = "claude-code";
+const DEFAULT_SINCE_DAYS = 30;
+const PROVIDER = "anthropic";
+function projectsRoot() {
+    return join(homedir(), ".claude", "projects");
+}
+function emptyTotals() {
+    return {
+        requests: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        costUsd: 0,
+        costConfidence: "modeled",
+        unpricedRequests: 0,
+        unpricedModels: [],
+    };
+}
+/**
+ * Every `.jsonl` under the projects root, at any depth.
+ *
+ * Depth matters here — see the module header. `withFileTypes` avoids a stat
+ * per entry, and a directory that cannot be read is skipped rather than
+ * aborting the walk: one unreadable project must not cost the other eleven
+ * thousand files.
+ */
+async function collectTranscripts(dir, out) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await collectTranscripts(full, out);
+        }
+        else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+            out.push(full);
+        }
+    }
+}
+function num(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+/**
+ * Fold one transcript into `totals`.
+ *
+ * Read line by line rather than into a string: these files reach tens of
+ * megabytes, and a full-history scan opens thousands of them.
+ *
+ * Dedup is by `message.id`, keeping the LARGEST output count seen for that id.
+ * A resumed session re-logs turns it has already written, and the re-logged
+ * copy can carry a higher output count than the first — taking the max rather
+ * than the first or last is what makes a resumed session total correct instead
+ * of either under- or double-counted. The map is per-file and discarded after,
+ * so it stays bounded no matter how many files a scan covers.
+ */
+async function foldTranscript(filePath, totals, unpriced) {
+    const seen = new Map();
+    const rl = createInterface({
+        input: createReadStream(filePath, { encoding: "utf8" }),
+        crlfDelay: Infinity,
+    });
+    try {
+        for await (const line of rl) {
+            if (!line || line.charCodeAt(0) !== 123 /* '{' */) {
+                continue;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                // A transcript being appended to while we read it ends in a partial
+                // line. That is normal, not corruption — skip it.
+                continue;
+            }
+            const record = parsed;
+            if (record.type !== "assistant" || !record.message?.usage) {
+                continue;
+            }
+            const usage = record.message.usage;
+            const id = record.message.id;
+            if (typeof id !== "string" || id.length === 0) {
+                continue;
+            }
+            const candidate = {
+                model: record.message.model ?? "unknown",
+                input: num(usage.input_tokens),
+                output: num(usage.output_tokens),
+                read: num(usage.cache_read_input_tokens),
+                create: num(usage.cache_creation_input_tokens),
+            };
+            const existing = seen.get(id);
+            if (!existing || candidate.output > existing.output) {
+                seen.set(id, candidate);
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+    for (const turn of seen.values()) {
+        totals.requests += 1;
+        totals.inputTokens += turn.input;
+        totals.outputTokens += turn.output;
+        totals.cacheReadTokens += turn.read;
+        totals.cacheCreationTokens += turn.create;
+        if (hasPricing(PROVIDER, turn.model)) {
+            totals.costUsd += calculateCost(PROVIDER, turn.model, {
+                input: turn.input,
+                output: turn.output,
+                total: turn.input + turn.output,
+                cacheReadTokens: turn.read,
+                cacheCreationTokens: turn.create,
+            });
+        }
+        else {
+            totals.unpricedRequests += 1;
+            unpriced.add(turn.model);
+        }
+    }
+}
+export async function createClaudeCodeReader() {
+    return {
+        descriptor: {
+            id: CLI_ID,
+            displayName: "Claude Code",
+            verified: true,
+            dedupStrategy: "message-id-keep-max",
+            costConfidence: "modeled",
+            requiresSqlite: false,
+        },
+        detect: async () => {
+            try {
+                const info = await stat(projectsRoot());
+                return info.isDirectory();
+            }
+            catch {
+                return false;
+            }
+        },
+        scan: async (options) => {
+            const totals = emptyTotals();
+            const errors = [];
+            const unpriced = new Set();
+            const files = [];
+            await collectTranscripts(projectsRoot(), files);
+            const sinceDays = options?.sinceDays ?? DEFAULT_SINCE_DAYS;
+            const cutoff = Number.isFinite(sinceDays) && sinceDays > 0
+                ? Date.now() - sinceDays * 86_400_000
+                : undefined;
+            let filesScanned = 0;
+            for (const file of files) {
+                try {
+                    if (cutoff !== undefined) {
+                        const info = await stat(file);
+                        if (info.mtimeMs < cutoff) {
+                            continue;
+                        }
+                    }
+                    await foldTranscript(file, totals, unpriced);
+                    filesScanned += 1;
+                }
+                catch (error) {
+                    // One unreadable transcript is a reportable fact, not a reason to
+                    // lose the totals from every other file in the scan.
+                    errors.push({
+                        cliId: CLI_ID,
+                        filePath: file,
+                        message: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+            totals.unpricedModels = [...unpriced].sort();
+            // Confidence stays "modeled" even when some turns went unpriced, and the
+            // distinction matters. "heuristic" means the number itself was estimated
+            // — Kiro's byte-count figure, say. Here every dollar in `costUsd` came
+            // from a real rate table; what is missing is turns, not accuracy. That
+            // incompleteness is already reported precisely by `unpricedRequests` and
+            // `unpricedModels` (on this machine: Claude Code's internal
+            // "<synthetic>" model), so downgrading the whole row would overstate the
+            // doubt and make a genuinely estimated total indistinguishable from this
+            // one.
+            totals.costUsd = Math.round(totals.costUsd * 1_000_000) / 1_000_000;
+            return { cliId: CLI_ID, totals, filesScanned, errors };
+        },
+    };
+}

package/dist/localUsage/codexReader.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Reads token usage out of Codex's own rollout transcripts.
+ *
+ * Layout: `~/.codex/sessions/<yyyy>/<mm>/<dd>/rollout-<iso>-<sessionId>.jsonl`.
+ * Each line is one of `session_meta`, `turn_context`, `response_item` or
+ * `event_msg`; usage lives on `event_msg` records whose `payload.type` is
+ * `token_count`.
+ *
+ * The counter semantics are the whole story here, and they are the opposite of
+ * the Claude Code reader's. Every `token_count` event carries BOTH a
+ * cumulative `total_token_usage` for the session and a per-turn
+ * `last_token_usage`. Summing the per-turn values is the obvious move and it is
+ * wrong: measured across all 108 sessions on a real machine, summing yields
+ * 9,191,613,238 tokens against a true 5,653,217,442 — an overstatement of
+ * 62.6%, and 195% on the worst single session. The per-turn value repeats
+ * across events within a turn, so it double-counts.
+ *
+ * The cumulative counter is authoritative and was monotonic in all 108
+ * sessions — it never resets mid-file — so the last one in the file is the
+ * session's true total. `Math.max` is still used rather than "last seen",
+ * because a counter that is only monotonic in every case observed is not the
+ * same as one that is guaranteed to be, and the max costs nothing.
+ *
+ * Cost is deliberately not computed. Codex is a ChatGPT subscription — the
+ * rollouts carry `rate_limits.plan_type` — so a per-token dollar figure would
+ * be an invention, not a measurement. The tokens are real; the cost is
+ * `unavailable`.
+ */
+import type { LocalUsageReader } from "../types/index.js";
+export declare function createCodexReader(): Promise<LocalUsageReader>;

package/dist/localUsage/codexReader.js

@@ -0,0 +1,218 @@
+/**
+ * Reads token usage out of Codex's own rollout transcripts.
+ *
+ * Layout: `~/.codex/sessions/<yyyy>/<mm>/<dd>/rollout-<iso>-<sessionId>.jsonl`.
+ * Each line is one of `session_meta`, `turn_context`, `response_item` or
+ * `event_msg`; usage lives on `event_msg` records whose `payload.type` is
+ * `token_count`.
+ *
+ * The counter semantics are the whole story here, and they are the opposite of
+ * the Claude Code reader's. Every `token_count` event carries BOTH a
+ * cumulative `total_token_usage` for the session and a per-turn
+ * `last_token_usage`. Summing the per-turn values is the obvious move and it is
+ * wrong: measured across all 108 sessions on a real machine, summing yields
+ * 9,191,613,238 tokens against a true 5,653,217,442 — an overstatement of
+ * 62.6%, and 195% on the worst single session. The per-turn value repeats
+ * across events within a turn, so it double-counts.
+ *
+ * The cumulative counter is authoritative and was monotonic in all 108
+ * sessions — it never resets mid-file — so the last one in the file is the
+ * session's true total. `Math.max` is still used rather than "last seen",
+ * because a counter that is only monotonic in every case observed is not the
+ * same as one that is guaranteed to be, and the max costs nothing.
+ *
+ * Cost is deliberately not computed. Codex is a ChatGPT subscription — the
+ * rollouts carry `rate_limits.plan_type` — so a per-token dollar figure would
+ * be an invention, not a measurement. The tokens are real; the cost is
+ * `unavailable`.
+ */
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import { readdir, stat } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+const CLI_ID = "codex";
+const DEFAULT_SINCE_DAYS = 30;
+function sessionsRoot() {
+    return join(homedir(), ".codex", "sessions");
+}
+function emptyTotals() {
+    return {
+        requests: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        costUsd: 0,
+        costConfidence: "unavailable",
+        unpricedRequests: 0,
+        unpricedModels: [],
+    };
+}
+async function collectRollouts(dir, out) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        // One unreadable date directory must not cost the rest of the scan.
+        return;
+    }
+    for (const entry of entries) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await collectRollouts(full, out);
+        }
+        else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+            out.push(full);
+        }
+    }
+}
+function num(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+/**
+ * Fold one rollout into a single session-level rollup.
+ *
+ * `billableEvents` counts only the `token_count` events where the cumulative
+ * total actually advanced. Counting every event instead would inherit exactly
+ * the repetition that makes summing the per-turn values wrong.
+ */
+async function readRollout(filePath) {
+    const rl = createInterface({
+        input: createReadStream(filePath, { encoding: "utf8" }),
+        crlfDelay: Infinity,
+    });
+    let model;
+    let bestTotal = -1;
+    let best;
+    let previousTotal = -1;
+    let billableEvents = 0;
+    try {
+        for await (const line of rl) {
+            // Cheap reject before JSON.parse: these files reach hundreds of MB and
+            // most lines are conversation content with no usage on them at all.
+            const isTokenCount = line.includes('"token_count"');
+            const isTurnContext = line.includes('"turn_context"');
+            if (!isTokenCount && !isTurnContext) {
+                continue;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                // A rollout being appended to while we read it ends mid-line.
+                continue;
+            }
+            const record = parsed;
+            if (record.type === "turn_context" && record.payload?.model) {
+                // Last one wins: a session can switch models partway through, and the
+                // most recent is the better single label for it.
+                model = record.payload.model;
+                continue;
+            }
+            if (record.payload?.type !== "token_count") {
+                continue;
+            }
+            const cumulative = record.payload.info?.total_token_usage;
+            if (!cumulative) {
+                continue;
+            }
+            const total = num(cumulative.total_tokens);
+            if (total > previousTotal) {
+                billableEvents += 1;
+            }
+            previousTotal = total;
+            if (total > bestTotal) {
+                bestTotal = total;
+                best = {
+                    input: num(cumulative.input_tokens),
+                    output: num(cumulative.output_tokens),
+                    cached: num(cumulative.cached_input_tokens),
+                };
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+    if (!best) {
+        return null;
+    }
+    return { model, billableEvents, ...best };
+}
+export async function createCodexReader() {
+    return {
+        descriptor: {
+            id: CLI_ID,
+            displayName: "Codex",
+            verified: true,
+            dedupStrategy: "session-dag",
+            costConfidence: "unavailable",
+            requiresSqlite: false,
+        },
+        detect: async () => {
+            try {
+                const info = await stat(sessionsRoot());
+                return info.isDirectory();
+            }
+            catch {
+                return false;
+            }
+        },
+        scan: async (options) => {
+            const totals = emptyTotals();
+            const errors = [];
+            const models = new Set();
+            const files = [];
+            await collectRollouts(sessionsRoot(), files);
+            const sinceDays = options?.sinceDays ?? DEFAULT_SINCE_DAYS;
+            const cutoff = Number.isFinite(sinceDays) && sinceDays > 0
+                ? Date.now() - sinceDays * 86_400_000
+                : undefined;
+            let filesScanned = 0;
+            for (const file of files) {
+                try {
+                    if (cutoff !== undefined) {
+                        const info = await stat(file);
+                        if (info.mtimeMs < cutoff) {
+                            continue;
+                        }
+                    }
+                    const rollup = await readRollout(file);
+                    filesScanned += 1;
+                    if (!rollup) {
+                        continue;
+                    }
+                    totals.requests += rollup.billableEvents;
+                    // `cached_input_tokens` is a SUBSET of `input_tokens` here — verified
+                    // on all 108 sessions, where input + output == total exactly and
+                    // cached <= input always. The other readers keep the two disjoint, so
+                    // the cached portion is subtracted out rather than reported twice; a
+                    // caller adding inputTokens + cacheReadTokens would otherwise
+                    // over-count Codex and not the rest.
+                    totals.inputTokens += Math.max(0, rollup.input - rollup.cached);
+                    totals.cacheReadTokens += rollup.cached;
+                    totals.outputTokens += rollup.output;
+                    if (rollup.model) {
+                        models.add(rollup.model);
+                    }
+                }
+                catch (error) {
+                    errors.push({
+                        cliId: CLI_ID,
+                        filePath: file,
+                        message: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+            // Every turn is unpriced by construction, not by accident: see the note
+            // on this module about Codex being a subscription. Naming the models
+            // keeps that legible instead of looking like a lookup that failed.
+            totals.unpricedRequests = totals.requests;
+            totals.unpricedModels = [...models].sort();
+            return { cliId: CLI_ID, totals, filesScanned, errors };
+        },
+    };
+}

package/dist/localUsage/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Local usage: token spend read from each CLI's own session logs.
+ *
+ * The proxy's ledger can only account for traffic that went through it, which
+ * caps coverage at the CLIs that expose a base-URL override. Every CLI writes
+ * a local transcript regardless, so reading those covers the rest — and covers
+ * history from before the proxy existed.
+ */
+import type { LocalUsageAggregateReport, LocalUsageScanOptions } from "../types/index.js";
+export { createLocalUsageReader, getLocalUsageDescriptors, getRegisteredLocalUsageCliIds, registerLocalUsageReader, } from "./localUsageReaderRegistry.js";
+/**
+ * Scan every registered reader whose CLI is actually present on this machine.
+ *
+ * "Not installed" and "failed" are reported separately and deliberately: a CLI
+ * the user never installed is not an error, and collapsing the two would make
+ * a broken reader indistinguishable from an absent one.
+ */
+export declare function readAllLocalUsage(options?: LocalUsageScanOptions): Promise<LocalUsageAggregateReport>;

package/dist/localUsage/index.js

@@ -0,0 +1,46 @@
+/**
+ * Local usage: token spend read from each CLI's own session logs.
+ *
+ * The proxy's ledger can only account for traffic that went through it, which
+ * caps coverage at the CLIs that expose a base-URL override. Every CLI writes
+ * a local transcript regardless, so reading those covers the rest — and covers
+ * history from before the proxy existed.
+ */
+import { createLocalUsageReader, getRegisteredLocalUsageCliIds, } from "./localUsageReaderRegistry.js";
+export { createLocalUsageReader, getLocalUsageDescriptors, getRegisteredLocalUsageCliIds, registerLocalUsageReader, } from "./localUsageReaderRegistry.js";
+/**
+ * Scan every registered reader whose CLI is actually present on this machine.
+ *
+ * "Not installed" and "failed" are reported separately and deliberately: a CLI
+ * the user never installed is not an error, and collapsing the two would make
+ * a broken reader indistinguishable from an absent one.
+ */
+export async function readAllLocalUsage(options) {
+    const totals = {};
+    const failures = [];
+    const notInstalled = [];
+    for (const cliId of getRegisteredLocalUsageCliIds()) {
+        try {
+            const reader = await createLocalUsageReader(cliId);
+            if (!(await reader.detect())) {
+                notInstalled.push(cliId);
+                continue;
+            }
+            const result = await reader.scan(options);
+            totals[cliId] = result.totals;
+        }
+        catch (error) {
+            // One reader throwing must not lose the others' results.
+            failures.push({
+                cliId,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return {
+        generatedAt: new Date().toISOString(),
+        totals,
+        failures,
+        notInstalled,
+    };
+}

package/dist/localUsage/localUsageReaderRegistry.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Registry of local-usage readers, one per CLI.
+ *
+ * Mirrors `providerRegistry.ts`: descriptors are static and always available,
+ * while the reader itself arrives through a dynamic import inside its factory.
+ * Same reason as the provider registry — a static import graph across a dozen
+ * readers is how circular dependencies start, and it would also force every
+ * reader's cost of loading onto a caller who only wanted one of them.
+ */
+import type { LocalUsageCliId, LocalUsageReader, LocalUsageReaderDescriptor, LocalUsageReaderRegistration } from "../types/index.js";
+export declare function registerLocalUsageReader(registration: LocalUsageReaderRegistration): void;
+export declare function getLocalUsageDescriptors(): LocalUsageReaderDescriptor[];
+export declare function getRegisteredLocalUsageCliIds(): LocalUsageCliId[];
+export declare function createLocalUsageReader(cliId: LocalUsageCliId): Promise<LocalUsageReader>;

package/dist/localUsage/localUsageReaderRegistry.js

@@ -0,0 +1,54 @@
+/**
+ * Registry of local-usage readers, one per CLI.
+ *
+ * Mirrors `providerRegistry.ts`: descriptors are static and always available,
+ * while the reader itself arrives through a dynamic import inside its factory.
+ * Same reason as the provider registry — a static import graph across a dozen
+ * readers is how circular dependencies start, and it would also force every
+ * reader's cost of loading onto a caller who only wanted one of them.
+ */
+const registry = new Map();
+export function registerLocalUsageReader(registration) {
+    registry.set(registration.descriptor.id, registration);
+}
+export function getLocalUsageDescriptors() {
+    return [...registry.values()].map((entry) => entry.descriptor);
+}
+export function getRegisteredLocalUsageCliIds() {
+    return [...registry.keys()];
+}
+export async function createLocalUsageReader(cliId) {
+    const registration = registry.get(cliId);
+    if (!registration) {
+        throw new Error(`No local-usage reader registered for "${cliId}". Registered: ${getRegisteredLocalUsageCliIds().join(", ") || "(none)"}`);
+    }
+    return registration.factory();
+}
+registerLocalUsageReader({
+    descriptor: {
+        id: "claude-code",
+        displayName: "Claude Code",
+        verified: true,
+        dedupStrategy: "message-id-keep-max",
+        costConfidence: "modeled",
+        requiresSqlite: false,
+    },
+    factory: async () => {
+        const { createClaudeCodeReader } = await import("./claudeCodeReader.js");
+        return createClaudeCodeReader();
+    },
+});
+registerLocalUsageReader({
+    descriptor: {
+        id: "codex",
+        displayName: "Codex",
+        verified: true,
+        dedupStrategy: "session-dag",
+        costConfidence: "unavailable",
+        requiresSqlite: false,
+    },
+    factory: async () => {
+        const { createCodexReader } = await import("./codexReader.js");
+        return createCodexReader();
+    },
+});

package/dist/types/index.d.ts

@@ -84,3 +84,4 @@ export * from "./modelPool.js";
 export * from "./requestRouter.js";
 export * from "./classifierRouter.js";
 export * from "./agentNetwork.js";
+export * from "./localUsage.js";

package/dist/types/index.js

@@ -95,3 +95,4 @@ export * from "./requestRouter.js";
 export * from "./classifierRouter.js";
 // Multi-Agent orchestration types
 export * from "./agentNetwork.js";
+export * from "./localUsage.js";