@juspay/neurolink 12.5.2 → 12.6.0

package/dist/cli/commands/proxy.js

@@ -2588,6 +2588,12 @@ async function startProxyRuntime(params) {
             }
             if (result.applied) {
                 logger.always(chalk.green(`  ✓ Auto-configured ${result.displayName} settings`));
+                if (result.note) {
+                    // A written file is not the same as a live configuration. Printing
+                    // the check without this reads as "done" for a client that is still
+                    // talking to its own upstream.
+                    logger.always(chalk.yellow(`    ↳ ${result.note}`));
+                }
                 logger.always(chalk.dim(`    Restart ${result.displayName} to connect through proxy`));
             }
         }
@@ -4042,6 +4048,9 @@ export const proxySetupCommand = {
                 }
                 if (result.applied) {
                     console.info(chalk.green(`  ✓ ${result.displayName} configured`));
+                    if (result.note) {
+                        console.info(chalk.yellow(`    ↳ ${result.note}`));
+                    }
                 }
             }
             // Done!

package/dist/cli/commands/usage.js

@@ -75,7 +75,11 @@ export class UsageCommandFactory {
         // given with no value, which is a mistake and must be rejected — a
         // truthiness check treats the two as the same and silently scans every
         // reader instead, reporting everything for a request that named nothing.
-        const wanted = argv.cli;
+        // "copilot-cli" is the pre-rename spelling and is still in the published
+        // LocalUsageCliId union, so it must keep resolving. Normalised here rather
+        // than registered twice: two descriptors for one reader would show the CLI
+        // twice in every report.
+        const wanted = argv.cli === "copilot-cli" ? "copilot" : argv.cli;
         const known = getLocalUsageDescriptors().map((d) => d.id);
         if (wanted !== undefined &&
             !known.includes(wanted)) {
@@ -140,6 +144,16 @@ export class UsageCommandFactory {
         for (const failure of report.failures) {
             logger.always(chalk.yellow(`  ${failure.cliId} failed: ${failure.message}`));
         }
+        // A reader that read nine of ten transcripts still reports totals, and
+        // those totals are wrong by the tenth. Printed next to the numbers they
+        // undercut, because a silently short total is the failure mode this whole
+        // command exists to avoid.
+        if (report.scanErrors.length > 0) {
+            logger.always(chalk.yellow(`  ${report.scanErrors.length} file(s) could not be read; totals are incomplete`));
+            for (const scanError of report.scanErrors.slice(0, 5)) {
+                logger.always(chalk.dim(`    ${scanError.cliId}: ${scanError.message}`));
+            }
+        }
         logger.always("");
     }
 }

package/dist/cli/proxy-clients/copilot.d.ts

@@ -28,12 +28,15 @@ import type { CliProxyClientConfigurator } from "../../types/index.js";
  */
 declare function getCopilotConfigDir(): string;
 declare function getCopilotEnvPath(): string;
+/** Whether any shell profile already sources the generated script. */
+declare function isEnvScriptSourced(): Promise<boolean>;
 export declare function setCopilotProxySettings(baseUrl: string, proxyKey?: string): Promise<boolean>;
 export declare function clearCopilotProxySettings(expectedBaseUrl?: string): Promise<boolean>;
 export declare const copilotConfigurator: CliProxyClientConfigurator;
 export declare const __copilotTestHooks: {
     getCopilotConfigDir: typeof getCopilotConfigDir;
     getCopilotEnvPath: typeof getCopilotEnvPath;
+    isEnvScriptSourced: typeof isEnvScriptSourced;
     setCopilotProxySettings: typeof setCopilotProxySettings;
     clearCopilotProxySettings: typeof clearCopilotProxySettings;
 };

package/dist/cli/proxy-clients/copilot.js

@@ -24,6 +24,7 @@
 import { homedir } from "os";
 import { join } from "path";
 import { logger } from "../../utils/logger.js";
+import { DEFAULT_PROXY_MODEL_ID } from "../../constants/proxyModels.js";
 import { writeFileAtomic } from "./snapshot.js";
 /**
  * Resolved per call rather than at module load so `detect()` and `apply()`
@@ -35,6 +36,31 @@ function getCopilotConfigDir() {
 function getCopilotEnvPath() {
     return join(homedir(), ".neurolink", "copilot-env.sh");
 }
+/**
+ * Shell profiles that could plausibly source the script.
+ *
+ * Checked to answer one question: has the user done the manual half? Writing
+ * the file is only half the job, and until the other half happens Copilot
+ * talks to GitHub, not the proxy.
+ */
+function getProfileCandidates() {
+    return [".zshrc", ".zprofile", ".bashrc", ".bash_profile", ".profile"].map((name) => join(homedir(), name));
+}
+/** Whether any shell profile already sources the generated script. */
+async function isEnvScriptSourced() {
+    const fs = await import("fs");
+    for (const profile of getProfileCandidates()) {
+        try {
+            if (fs.readFileSync(profile, "utf8").includes("copilot-env.sh")) {
+                return true;
+            }
+        }
+        catch {
+            // Absent or unreadable profile — not evidence either way, keep looking.
+        }
+    }
+    return false;
+}
 function buildCopilotEnvScript(baseUrl, proxyKey) {
     return [
         "# Generated by `neurolink proxy` — do not edit.",
@@ -46,6 +72,11 @@ function buildCopilotEnvScript(baseUrl, proxyKey) {
         'export COPILOT_PROVIDER_TYPE="openai"',
         `export COPILOT_PROVIDER_BASE_URL="${baseUrl}"`,
         `export COPILOT_PROVIDER_API_KEY="${proxyKey}"`,
+        // Without a model id Copilot's BYOK path refuses to start — "BYOK
+        // providers require an explicit model" — so a script that stops at the
+        // base URL still needs `--model` on every invocation. Export a default and
+        // let the user override it after sourcing.
+        `export COPILOT_PROVIDER_MODEL_ID="\${COPILOT_PROVIDER_MODEL_ID:-${DEFAULT_PROXY_MODEL_ID}}"`,
         "",
     ].join("\n");
 }
@@ -101,6 +132,13 @@ export async function clearCopilotProxySettings(expectedBaseUrl) {
 export const copilotConfigurator = {
     id: "copilot",
     displayName: "Copilot CLI",
+    // Copilot is the only client whose apply() can fully succeed and still have
+    // no effect: the script it writes does nothing until a shell profile sources
+    // it. Without this note the proxy prints a green check for a file nothing
+    // reads, which is indistinguishable from working.
+    postApplyNote: async () => (await isEnvScriptSourced())
+        ? null
+        : "Copilot reads provider settings from the environment only. Add this line to your shell profile, then open a new shell:\n      [ -f ~/.neurolink/copilot-env.sh ] && . ~/.neurolink/copilot-env.sh",
     detect: async () => {
         const fs = await import("fs");
         try {
@@ -118,6 +156,7 @@ export const copilotConfigurator = {
 export const __copilotTestHooks = {
     getCopilotConfigDir,
     getCopilotEnvPath,
+    isEnvScriptSourced,
     setCopilotProxySettings,
     clearCopilotProxySettings,
 };

package/dist/cli/proxy-clients/registry.js

@@ -34,7 +34,30 @@ export async function applyAllClients(proxyBaseUrl) {
             const applied = (await client.detect())
                 ? await client.apply(proxyBaseUrl)
                 : false;
-            results.push({ id: client.id, displayName: client.displayName, applied });
+            // Only ask for a note when something was actually written: a note on a
+            // client that was skipped would read as an instruction to act on a
+            // configuration that does not exist.
+            //
+            // Computed in its own try, outside apply()'s. A note is advisory; a
+            // throwing implementation must not be able to turn a successful write
+            // into `applied: false` and an error the caller reports as a failed
+            // configuration. Dormant today only because the one implementation
+            // swallows its own errors, which is not a property to rely on.
+            let note = null;
+            if (applied) {
+                try {
+                    note = (await client.postApplyNote?.(proxyBaseUrl)) ?? null;
+                }
+                catch (noteError) {
+                    logger.debug(`[proxy] ${client.id} post-apply note failed: ${noteError instanceof Error ? noteError.message : String(noteError)}`);
+                }
+            }
+            results.push({
+                id: client.id,
+                displayName: client.displayName,
+                applied,
+                ...(note === null ? {} : { note }),
+            });
         }
         catch (error) {
             const wrapped = error instanceof Error ? error : new Error(String(error));

package/dist/constants/proxyModels.d.ts

@@ -20,3 +20,17 @@
  * better than the empty map it replaces.
  */
 export declare const DEFAULT_PROXY_MODEL_IDS: readonly string[];
+/**
+ * The model a client is pointed at when it requires one and the user has not
+ * chosen.
+ *
+ * Copilot's BYOK path refuses to start without an explicit model —
+ * `copilot -p "..."` fails with "BYOK providers require an explicit model" —
+ * so a configurator that writes a base URL and stops has produced something
+ * unusable without an extra flag on every invocation.
+ *
+ * Sonnet rather than Opus or Haiku, matching the reasoning already recorded on
+ * DEFAULT_MODELS_BY_TIER's `api` entry in src/lib/models/anthropicModels.ts:
+ * the balance most callers want when nobody has expressed a preference.
+ */
+export declare const DEFAULT_PROXY_MODEL_ID = "claude-sonnet-4-6";

package/dist/constants/proxyModels.js

@@ -34,3 +34,17 @@ export const DEFAULT_PROXY_MODEL_IDS = [
     "gemini-2.5-pro",
     "gemini-2.5-flash",
 ];
+/**
+ * The model a client is pointed at when it requires one and the user has not
+ * chosen.
+ *
+ * Copilot's BYOK path refuses to start without an explicit model —
+ * `copilot -p "..."` fails with "BYOK providers require an explicit model" —
+ * so a configurator that writes a base URL and stops has produced something
+ * unusable without an extra flag on every invocation.
+ *
+ * Sonnet rather than Opus or Haiku, matching the reasoning already recorded on
+ * DEFAULT_MODELS_BY_TIER's `api` entry in src/lib/models/anthropicModels.ts:
+ * the balance most callers want when nobody has expressed a preference.
+ */
+export const DEFAULT_PROXY_MODEL_ID = "claude-sonnet-4-6";

package/dist/localUsage/copilotCliReader.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Reads token usage out of Copilot CLI's local SQLite store.
+ *
+ * Store: `~/.copilot/session-store.db`. Usage lives on the
+ * `assistant_usage_events` table — one INSERT-only row per assistant turn,
+ * with `model`, `input_tokens`, `output_tokens`, `cache_read_tokens`,
+ * `cache_write_tokens`, `reasoning_tokens` and a `created_at` timestamp
+ * (ISO-8601 with a `Z` suffix). Confirmed no duplicate `(session_id,
+ * turn_index)` pair exists on a reference machine, so — like OpenCode's
+ * `message` table — this needs no dedup logic beyond the table's own
+ * uniqueness: every row is counted once, matching the `rowid-high-water-mark`
+ * strategy already established for that reader.
+ *
+ * The same database also holds a JSONL-adjacent `session.shutdown` event with
+ * its own `modelMetrics`/`tokenDetails` payload (written to
+ * `~/.copilot/session-state/*\/events.jsonl`, not this database). It was
+ * deliberately NOT used here: cross-checking real sessions confirmed the two
+ * sources report identical totals for the sessions they both cover, so
+ * combining them would double-count rather than add coverage. The SQLite
+ * table is the sole source; the tradeoff is a disclosed gap for any history
+ * that predates the table's introduction.
+ *
+ * `cache_read_tokens` and `cache_write_tokens` are both SUBSETS of
+ * `input_tokens`, not disjoint — confirmed arithmetically against a real
+ * `session.shutdown` record (session `c2c38d0b`): `tokenDetails.input.tokenCount
+ * = 3`, `cache_write = 24047`, and `usage.inputTokens = 24050` — exactly
+ * `3 + 24047`, with nothing left over for a separate additive interpretation.
+ * So `inputTokens` here is `input_tokens - cache_read_tokens -
+ * cache_write_tokens`, the same style of subtraction `codexReader.ts`,
+ * `qwenCodeReader.ts` and `geminiCliReader.ts` make for the same reason: this
+ * subsystem's `LocalUsageTotals.inputTokens` + `.cacheReadTokens` must sum to
+ * the true prompt size without double-counting. `reasoning_tokens` folds into
+ * output — Copilot's own SDK types (`ShutdownModelMetricUsage`) group it
+ * alongside `outputTokens` as a further breakdown of output, not a separate
+ * accounting bucket.
+ *
+ * Cost is deliberately `unavailable`. The table's own `request_multiplier`
+ * and `total_nano_aiu` columns are Copilot's request-quota accounting, not a
+ * USD figure — the SDK's own generated types tag the closest concept,
+ * `ShutdownModelMetricUsage.cost`, `@experimental`, and every real sample row
+ * on the reference machine had `request_multiplier: 0.0`. Modeling a
+ * per-token dollar figure from public list prices would also ignore that
+ * Copilot CLI is typically used under a flat-rate Copilot subscription, the
+ * same reasoning that keeps Codex's confidence `unavailable`. This holds even
+ * when the underlying model is a metered vendor's (e.g. `claude-haiku-4-5` on
+ * the reference machine) — Copilot's telemetry layer normalizes across
+ * backend vendors into its own accounting convention, and this reader has no
+ * way to tell whether a given row was billed by the minute, by the token, or
+ * not separately billed at all.
+ */
+import type { LocalUsageReader } from "../types/index.js";
+export declare function createCopilotCliReader(): Promise<LocalUsageReader>;

package/dist/localUsage/copilotCliReader.js

@@ -0,0 +1,200 @@
+/**
+ * Reads token usage out of Copilot CLI's local SQLite store.
+ *
+ * Store: `~/.copilot/session-store.db`. Usage lives on the
+ * `assistant_usage_events` table — one INSERT-only row per assistant turn,
+ * with `model`, `input_tokens`, `output_tokens`, `cache_read_tokens`,
+ * `cache_write_tokens`, `reasoning_tokens` and a `created_at` timestamp
+ * (ISO-8601 with a `Z` suffix). Confirmed no duplicate `(session_id,
+ * turn_index)` pair exists on a reference machine, so — like OpenCode's
+ * `message` table — this needs no dedup logic beyond the table's own
+ * uniqueness: every row is counted once, matching the `rowid-high-water-mark`
+ * strategy already established for that reader.
+ *
+ * The same database also holds a JSONL-adjacent `session.shutdown` event with
+ * its own `modelMetrics`/`tokenDetails` payload (written to
+ * `~/.copilot/session-state/*\/events.jsonl`, not this database). It was
+ * deliberately NOT used here: cross-checking real sessions confirmed the two
+ * sources report identical totals for the sessions they both cover, so
+ * combining them would double-count rather than add coverage. The SQLite
+ * table is the sole source; the tradeoff is a disclosed gap for any history
+ * that predates the table's introduction.
+ *
+ * `cache_read_tokens` and `cache_write_tokens` are both SUBSETS of
+ * `input_tokens`, not disjoint — confirmed arithmetically against a real
+ * `session.shutdown` record (session `c2c38d0b`): `tokenDetails.input.tokenCount
+ * = 3`, `cache_write = 24047`, and `usage.inputTokens = 24050` — exactly
+ * `3 + 24047`, with nothing left over for a separate additive interpretation.
+ * So `inputTokens` here is `input_tokens - cache_read_tokens -
+ * cache_write_tokens`, the same style of subtraction `codexReader.ts`,
+ * `qwenCodeReader.ts` and `geminiCliReader.ts` make for the same reason: this
+ * subsystem's `LocalUsageTotals.inputTokens` + `.cacheReadTokens` must sum to
+ * the true prompt size without double-counting. `reasoning_tokens` folds into
+ * output — Copilot's own SDK types (`ShutdownModelMetricUsage`) group it
+ * alongside `outputTokens` as a further breakdown of output, not a separate
+ * accounting bucket.
+ *
+ * Cost is deliberately `unavailable`. The table's own `request_multiplier`
+ * and `total_nano_aiu` columns are Copilot's request-quota accounting, not a
+ * USD figure — the SDK's own generated types tag the closest concept,
+ * `ShutdownModelMetricUsage.cost`, `@experimental`, and every real sample row
+ * on the reference machine had `request_multiplier: 0.0`. Modeling a
+ * per-token dollar figure from public list prices would also ignore that
+ * Copilot CLI is typically used under a flat-rate Copilot subscription, the
+ * same reasoning that keeps Codex's confidence `unavailable`. This holds even
+ * when the underlying model is a metered vendor's (e.g. `claude-haiku-4-5` on
+ * the reference machine) — Copilot's telemetry layer normalizes across
+ * backend vendors into its own accounting convention, and this reader has no
+ * way to tell whether a given row was billed by the minute, by the token, or
+ * not separately billed at all.
+ */
+import { stat } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { resolveScanCutoffMs } from "./scanWindow.js";
+const CLI_ID = "copilot";
+function databasePath() {
+    return join(homedir(), ".copilot", "session-store.db");
+}
+function emptyTotals() {
+    return {
+        requests: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        costUsd: 0,
+        costConfidence: "unavailable",
+        unpricedRequests: 0,
+        unpricedModels: [],
+    };
+}
+function num(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+/**
+ * `created_at` is an ISO-8601-with-`Z` text column, so the cutoff needs to be
+ * the same shape to sort and compare correctly in SQL. `Infinity`/`undefined`
+ * (no filter) becomes the epoch, matching `openCodeReader.ts`'s `?? 0`
+ * convention of expressing "unbounded" as "since the earliest possible time"
+ * rather than leaving the bound parameter out.
+ */
+function cutoffIso(sinceDays) {
+    const cutoffMs = resolveScanCutoffMs(sinceDays) ?? 0;
+    return new Date(cutoffMs).toISOString();
+}
+export async function createCopilotCliReader() {
+    return {
+        descriptor: {
+            id: CLI_ID,
+            displayName: "Copilot CLI",
+            verified: true,
+            dedupStrategy: "rowid-high-water-mark",
+            costConfidence: "unavailable",
+            requiresSqlite: true,
+        },
+        detect: async () => {
+            try {
+                const info = await stat(databasePath());
+                return info.isFile();
+            }
+            catch {
+                return false;
+            }
+        },
+        scan: async (options) => {
+            const totals = emptyTotals();
+            const errors = [];
+            const models = new Set();
+            const dbPath = databasePath();
+            // `node:sqlite` is experimental and may be absent or change shape — the
+            // same lazy, validated import `openCodeReader.ts` uses, so one runtime
+            // missing it degrades to a reported failure for this reader alone.
+            let DatabaseSync;
+            try {
+                const sqlite = await import("node:sqlite");
+                if (typeof sqlite === "object" &&
+                    sqlite !== null &&
+                    "DatabaseSync" in sqlite &&
+                    typeof sqlite.DatabaseSync ===
+                        "function") {
+                    DatabaseSync = sqlite.DatabaseSync;
+                }
+            }
+            catch (error) {
+                errors.push({
+                    cliId: CLI_ID,
+                    filePath: dbPath,
+                    message: `node:sqlite unavailable on this runtime: ${error instanceof Error ? error.message : String(error)}`,
+                });
+                return { cliId: CLI_ID, totals, filesScanned: 0, errors };
+            }
+            if (!DatabaseSync) {
+                errors.push({
+                    cliId: CLI_ID,
+                    filePath: dbPath,
+                    message: "node:sqlite did not expose a callable DatabaseSync — the experimental API has likely changed shape",
+                });
+                return { cliId: CLI_ID, totals, filesScanned: 0, errors };
+            }
+            const cutoff = cutoffIso(options?.sinceDays);
+            let db;
+            try {
+                // Read-only: this is the user's live store and Copilot CLI may be
+                // running. Bound parameter, not interpolation — never splice a
+                // caller-influenced value into SQL text.
+                db = new DatabaseSync(dbPath, { readOnly: true });
+                const rows = db
+                    .prepare("SELECT model, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, reasoning_tokens, created_at FROM assistant_usage_events WHERE created_at >= ?")
+                    .all(cutoff);
+                for (const row of rows) {
+                    const inputTokens = num(row.input_tokens);
+                    const outputTokens = num(row.output_tokens);
+                    const cacheRead = num(row.cache_read_tokens);
+                    const cacheWrite = num(row.cache_write_tokens);
+                    const reasoning = num(row.reasoning_tokens);
+                    if (inputTokens === 0 &&
+                        outputTokens === 0 &&
+                        cacheRead === 0 &&
+                        cacheWrite === 0 &&
+                        reasoning === 0) {
+                        continue;
+                    }
+                    totals.requests += 1;
+                    totals.inputTokens += Math.max(0, inputTokens - cacheRead - cacheWrite);
+                    totals.outputTokens += outputTokens + reasoning;
+                    totals.cacheReadTokens += cacheRead;
+                    totals.cacheCreationTokens += cacheWrite;
+                    // Every counted row contributes a name. A null model still raised
+                    // unpricedRequests, so skipping it here produced a report saying N
+                    // turns went unpriced while naming fewer than N models — the operator
+                    // is then chasing a gap the report refuses to identify.
+                    models.add(row.model ?? "unknown");
+                }
+            }
+            catch (error) {
+                errors.push({
+                    cliId: CLI_ID,
+                    filePath: dbPath,
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+            finally {
+                try {
+                    db?.close();
+                }
+                catch {
+                    // Closing a database that failed to open is not a second failure.
+                }
+            }
+            totals.unpricedRequests = totals.requests;
+            totals.unpricedModels = [...models].sort();
+            return {
+                cliId: CLI_ID,
+                totals,
+                filesScanned: totals.requests > 0 || errors.length === 0 ? 1 : 0,
+                errors,
+            };
+        },
+    };
+}

package/dist/localUsage/geminiCliReader.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Reads token usage out of Gemini CLI's own session transcripts.
+ *
+ * Layout, confirmed on a real machine (18 files spanning June–August 2026):
+ * `~/.gemini/tmp/<projectSlug>/chats/session-<timestamp>-<id>.jsonl`. The
+ * sibling `~/.gemini/history/<projectSlug>/` directories are a git-based
+ * shadow-history of edited files, not chat logs — no JSONL lives there.
+ *
+ * Each file is a small append-only patch log rather than one JSON object per
+ * line of "the same shape": line 0 is a header (`sessionId`, `projectHash`,
+ * `startTime`, `lastUpdated`, `kind`); every line after that is either
+ * `{"$set": {...}}` (a partial merge — `messages` on session bootstrap,
+ * scalar fields like `lastUpdated`/`summary` afterwards) or a bare message
+ * object appended directly. Confirmed on the installed CLI's own bundled
+ * source (`@google/gemini-cli` `ChatRecordingService.pushMessage`): a bare
+ * append is `appendRecord(msg)` with no wrapper, which is why real transcripts
+ * mix both shapes. This reader unwraps `$set.messages[]` (only ever seen once
+ * per file, holding the single injected `<session_context>` bootstrap
+ * message) and reads bare objects that carry `id`/`type` directly.
+ *
+ * The installed source also revealed a real double-write race, invisible in
+ * this machine's own samples (0 duplicate ids across all 18 files) but
+ * reachable on any machine: `recordMessage()` first pushes a `type: "gemini"`
+ * message with whatever `tokens` value is already queued (often `null`,
+ * before the response's usage metadata has arrived), and
+ * `recordMessageTokens()` — called separately once usage arrives — re-pushes
+ * the SAME message id with `tokens` now filled in if it finds the last
+ * message still token-less. `pushMessage()` unconditionally appends a new
+ * line every time it is called, even for an id it has already written. So the
+ * same `id` can legitimately appear twice: once without tokens, once with.
+ * Dedup here keeps, per id, whichever record has the larger `tokens.total`
+ * (a record with no tokens contributes 0), which is correct for both that
+ * race and an ordinary resumed-session replay. The map is per-file, mirroring
+ * `claudeCodeReader.ts`.
+ *
+ * `tokens` is `{input, output, cached, thoughts, tool, total}`, and the source
+ * (`recordMessageTokens`) maps it straight from the GenAI response's own
+ * `usageMetadata` — `input = promptTokenCount`, `output = candidatesTokenCount`,
+ * `cached = cachedContentTokenCount`, `thoughts = thoughtsTokenCount`,
+ * `tool = toolUsePromptTokenCount`, `total = totalTokenCount`. Real data
+ * confirms `total = input + output + thoughts + tool` and that `cached` is a
+ * SUBSET of `input`: the one real record with nonzero cache had
+ * `input: 12121, cached: 4073`, and `total (12344) = input (12121) + output
+ * (1) + thoughts (222)` — cached tokens are not added on top of input, they
+ * are already inside it. So `inputTokens` here is `input - cached`, the same
+ * subtraction `codexReader.ts` and `qwenCodeReader.ts` make for the same
+ * reason: this subsystem's `LocalUsageTotals.inputTokens` +
+ * `.cacheReadTokens` must sum to the true prompt size without double-counting.
+ * No cache-CREATION concept exists in this API family's usage metadata, so
+ * `cacheCreationTokens` stays 0.
+ *
+ * The write path also nests subagent transcripts one level deeper —
+ * `chats/<parentSessionId>/<subagentSessionId>.jsonl`, per the same source —
+ * so this reader recurses under `chats/` rather than globbing one level, even
+ * though no nested subagent file exists on the machine this was verified
+ * against.
+ *
+ * Cost is deliberately `unavailable`. Gemini CLI supports three genuinely
+ * different auth modes with unrelated billing (`gemini-api-key`: metered, and
+ * the Flash models specifically have a real free tier; `oauth-personal`: free,
+ * rate-limited; `vertex-ai`: billed to a GCP project at negotiated rates), and
+ * no session record — not the header, not a message — carries which mode was
+ * active when it was written. `settings.json` records only the CURRENT mode,
+ * which cannot be projected onto historical sessions. Modeling a per-token
+ * dollar figure from the public API price list would misrepresent every
+ * free-tier or Vertex-billed session as if it were pay-as-you-go. Concretely,
+ * on the reference machine even the majority model logged (`gemini-3.5-flash`,
+ * 12 of 14 sampled turns) has no entry in `pricing.ts` at all — only the
+ * minority model (`gemini-3-flash-preview`) does — so most real traffic would
+ * be unpriced regardless.
+ */
+import type { LocalUsageReader } from "../types/index.js";
+export declare function createGeminiCliReader(): Promise<LocalUsageReader>;