@cruxy/cli 0.18.0 → 0.19.0

package/dist/config/schema.d.ts

@@ -408,6 +408,138 @@ export declare const MemoryConfigSchema: z.ZodObject<{
     maxRecallTokens?: number | undefined;
 }>;
 export type MemoryConfig = z.infer<typeof MemoryConfigSchema>;
+/** A per-tier price, in the user's own currency, PER MILLION TOKENS (C.22). */
+export declare const TierPriceSchema: z.ZodObject<{
+    /** Price per 1,000,000 input tokens. */
+    input: z.ZodNumber;
+    /** Price per 1,000,000 output tokens. */
+    output: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    input: number;
+    output: number;
+}, {
+    input: number;
+    output: number;
+}>;
+/**
+ * Usage telemetry + cost tracking (C.22): LOCAL usage accounting only — nothing
+ * here is ever transmitted. Costs are opt-in and honest: prices are per-TIER and
+ * per-million-tokens, configured by the user; with none set, tokens are shown
+ * and cost is omitted (cruxy ships no bundled price table). The `prices` keys are
+ * the fixed {@link MODEL_TIERS}, so an upstream model name can never appear here
+ * (U.8 gag holds by construction) and a mistyped tier is rejected at config load.
+ */
+export declare const UsageConfigSchema: z.ZodObject<{
+    /** Master switch. When false, no usage is collected, persisted, or shown. */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /** Currency label to prefix costs with (e.g. "$", "€"). Empty ⇒ no symbol is
+     * assumed — a bare number is shown, since the user configured the prices. */
+    currency: z.ZodDefault<z.ZodString>;
+    /** How many past runs to keep in the store; older ones are pruned oldest-first. */
+    retention: z.ZodDefault<z.ZodNumber>;
+    /** Per-tier prices. Any tier omitted is simply unpriced (cost omitted for it). */
+    prices: z.ZodDefault<z.ZodObject<{
+        kavi: z.ZodOptional<z.ZodObject<{
+            /** Price per 1,000,000 input tokens. */
+            input: z.ZodNumber;
+            /** Price per 1,000,000 output tokens. */
+            output: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            input: number;
+            output: number;
+        }, {
+            input: number;
+            output: number;
+        }>>;
+        vaani: z.ZodOptional<z.ZodObject<{
+            /** Price per 1,000,000 input tokens. */
+            input: z.ZodNumber;
+            /** Price per 1,000,000 output tokens. */
+            output: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            input: number;
+            output: number;
+        }, {
+            input: number;
+            output: number;
+        }>>;
+        mira: z.ZodOptional<z.ZodObject<{
+            /** Price per 1,000,000 input tokens. */
+            input: z.ZodNumber;
+            /** Price per 1,000,000 output tokens. */
+            output: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            input: number;
+            output: number;
+        }, {
+            input: number;
+            output: number;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        kavi?: {
+            input: number;
+            output: number;
+        } | undefined;
+        vaani?: {
+            input: number;
+            output: number;
+        } | undefined;
+        mira?: {
+            input: number;
+            output: number;
+        } | undefined;
+    }, {
+        kavi?: {
+            input: number;
+            output: number;
+        } | undefined;
+        vaani?: {
+            input: number;
+            output: number;
+        } | undefined;
+        mira?: {
+            input: number;
+            output: number;
+        } | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    enabled: boolean;
+    retention: number;
+    currency: string;
+    prices: {
+        kavi?: {
+            input: number;
+            output: number;
+        } | undefined;
+        vaani?: {
+            input: number;
+            output: number;
+        } | undefined;
+        mira?: {
+            input: number;
+            output: number;
+        } | undefined;
+    };
+}, {
+    enabled?: boolean | undefined;
+    retention?: number | undefined;
+    currency?: string | undefined;
+    prices?: {
+        kavi?: {
+            input: number;
+            output: number;
+        } | undefined;
+        vaani?: {
+            input: number;
+            output: number;
+        } | undefined;
+        mira?: {
+            input: number;
+            output: number;
+        } | undefined;
+    } | undefined;
+}>;
+export type UsageConfig = z.infer<typeof UsageConfigSchema>;
 /** MCP server entry — stdio or URL transport (wired up in a later phase). */
 export declare const McpServerSchema: z.ZodObject<{
     command: z.ZodOptional<z.ZodString>;
@@ -767,6 +899,116 @@ export declare const CruxyConfigSchema: z.ZodObject<{
         enabled?: boolean | undefined;
         maxRecallTokens?: number | undefined;
     }>>;
+    usage: z.ZodDefault<z.ZodObject<{
+        /** Master switch. When false, no usage is collected, persisted, or shown. */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /** Currency label to prefix costs with (e.g. "$", "€"). Empty ⇒ no symbol is
+         * assumed — a bare number is shown, since the user configured the prices. */
+        currency: z.ZodDefault<z.ZodString>;
+        /** How many past runs to keep in the store; older ones are pruned oldest-first. */
+        retention: z.ZodDefault<z.ZodNumber>;
+        /** Per-tier prices. Any tier omitted is simply unpriced (cost omitted for it). */
+        prices: z.ZodDefault<z.ZodObject<{
+            kavi: z.ZodOptional<z.ZodObject<{
+                /** Price per 1,000,000 input tokens. */
+                input: z.ZodNumber;
+                /** Price per 1,000,000 output tokens. */
+                output: z.ZodNumber;
+            }, "strict", z.ZodTypeAny, {
+                input: number;
+                output: number;
+            }, {
+                input: number;
+                output: number;
+            }>>;
+            vaani: z.ZodOptional<z.ZodObject<{
+                /** Price per 1,000,000 input tokens. */
+                input: z.ZodNumber;
+                /** Price per 1,000,000 output tokens. */
+                output: z.ZodNumber;
+            }, "strict", z.ZodTypeAny, {
+                input: number;
+                output: number;
+            }, {
+                input: number;
+                output: number;
+            }>>;
+            mira: z.ZodOptional<z.ZodObject<{
+                /** Price per 1,000,000 input tokens. */
+                input: z.ZodNumber;
+                /** Price per 1,000,000 output tokens. */
+                output: z.ZodNumber;
+            }, "strict", z.ZodTypeAny, {
+                input: number;
+                output: number;
+            }, {
+                input: number;
+                output: number;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            kavi?: {
+                input: number;
+                output: number;
+            } | undefined;
+            vaani?: {
+                input: number;
+                output: number;
+            } | undefined;
+            mira?: {
+                input: number;
+                output: number;
+            } | undefined;
+        }, {
+            kavi?: {
+                input: number;
+                output: number;
+            } | undefined;
+            vaani?: {
+                input: number;
+                output: number;
+            } | undefined;
+            mira?: {
+                input: number;
+                output: number;
+            } | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        enabled: boolean;
+        retention: number;
+        currency: string;
+        prices: {
+            kavi?: {
+                input: number;
+                output: number;
+            } | undefined;
+            vaani?: {
+                input: number;
+                output: number;
+            } | undefined;
+            mira?: {
+                input: number;
+                output: number;
+            } | undefined;
+        };
+    }, {
+        enabled?: boolean | undefined;
+        retention?: number | undefined;
+        currency?: string | undefined;
+        prices?: {
+            kavi?: {
+                input: number;
+                output: number;
+            } | undefined;
+            vaani?: {
+                input: number;
+                output: number;
+            } | undefined;
+            mira?: {
+                input: number;
+                output: number;
+            } | undefined;
+        } | undefined;
+    }>>;
     mcpServers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         command: z.ZodOptional<z.ZodString>;
         args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -789,6 +1031,25 @@ export declare const CruxyConfigSchema: z.ZodObject<{
         enabled: boolean;
         maxRecallTokens: number;
     };
+    usage: {
+        enabled: boolean;
+        retention: number;
+        currency: string;
+        prices: {
+            kavi?: {
+                input: number;
+                output: number;
+            } | undefined;
+            vaani?: {
+                input: number;
+                output: number;
+            } | undefined;
+            mira?: {
+                input: number;
+                output: number;
+            } | undefined;
+        };
+    };
     checkpoint: {
         enabled: boolean;
         retention: number;
@@ -886,6 +1147,25 @@ export declare const CruxyConfigSchema: z.ZodObject<{
         enabled?: boolean | undefined;
         maxRecallTokens?: number | undefined;
     } | undefined;
+    usage?: {
+        enabled?: boolean | undefined;
+        retention?: number | undefined;
+        currency?: string | undefined;
+        prices?: {
+            kavi?: {
+                input: number;
+                output: number;
+            } | undefined;
+            vaani?: {
+                input: number;
+                output: number;
+            } | undefined;
+            mira?: {
+                input: number;
+                output: number;
+            } | undefined;
+        } | undefined;
+    } | undefined;
     checkpoint?: {
         enabled?: boolean | undefined;
         retention?: number | undefined;

package/dist/config/schema.js

@@ -290,6 +290,43 @@ export const MemoryConfigSchema = z
     maxRecallTokens: z.number().int().positive().default(1000),
 })
     .strict();
+/** A per-tier price, in the user's own currency, PER MILLION TOKENS (C.22). */
+export const TierPriceSchema = z
+    .object({
+    /** Price per 1,000,000 input tokens. */
+    input: z.number().nonnegative(),
+    /** Price per 1,000,000 output tokens. */
+    output: z.number().nonnegative(),
+})
+    .strict();
+/**
+ * Usage telemetry + cost tracking (C.22): LOCAL usage accounting only — nothing
+ * here is ever transmitted. Costs are opt-in and honest: prices are per-TIER and
+ * per-million-tokens, configured by the user; with none set, tokens are shown
+ * and cost is omitted (cruxy ships no bundled price table). The `prices` keys are
+ * the fixed {@link MODEL_TIERS}, so an upstream model name can never appear here
+ * (U.8 gag holds by construction) and a mistyped tier is rejected at config load.
+ */
+export const UsageConfigSchema = z
+    .object({
+    /** Master switch. When false, no usage is collected, persisted, or shown. */
+    enabled: z.boolean().default(true),
+    /** Currency label to prefix costs with (e.g. "$", "€"). Empty ⇒ no symbol is
+     * assumed — a bare number is shown, since the user configured the prices. */
+    currency: z.string().default(""),
+    /** How many past runs to keep in the store; older ones are pruned oldest-first. */
+    retention: z.number().int().positive().default(50),
+    /** Per-tier prices. Any tier omitted is simply unpriced (cost omitted for it). */
+    prices: z
+        .object({
+        kavi: TierPriceSchema.optional(),
+        vaani: TierPriceSchema.optional(),
+        mira: TierPriceSchema.optional(),
+    })
+        .strict()
+        .default({}),
+})
+    .strict();
 /** MCP server entry — stdio or URL transport (wired up in a later phase). */
 export const McpServerSchema = z
     .object({
@@ -316,6 +353,7 @@ export const CruxyConfigSchema = z
     hooks: HooksConfigSchema.default({}),
     routing: RoutingConfigSchema.default({}),
     memory: MemoryConfigSchema.default({}),
+    usage: UsageConfigSchema.default({}),
     mcpServers: z.record(z.string(), McpServerSchema).default({}),
     logLevel: z.enum(LOG_LEVELS).default("info"),
 })

package/dist/constants.d.ts

@@ -41,6 +41,13 @@ export declare const MEMORY_FILE_NAME = "entries.json";
  * (`~/.cruxy/memory-trust.json`) — its own file, independent of hook trust, so
  * cloning a repo carries zero memory trust (C.29 supply-chain safety). */
 export declare const MEMORY_TRUST_FILE_NAME = "memory-trust.json";
+/**
+ * Usage telemetry + cost tracking (C.22). Per-run/per-session usage records live
+ * in the GLOBAL dir only (`~/.cruxy/usage/runs.json`), `0600` — LOCAL accounting
+ * of your own usage, never transmitted. Pure data, validated, never eval'd.
+ */
+export declare const USAGE_DIR_NAME = "usage";
+export declare const USAGE_FILE_NAME = "runs.json";
 /**
  * Absolute path of the shipped builtin skills directory (`<pkg>/skills`).
  * Anchored the same way as the package.json lookup above: both `dist/` and

package/dist/constants.js

@@ -61,6 +61,13 @@ export const MEMORY_FILE_NAME = "entries.json";
  * (`~/.cruxy/memory-trust.json`) — its own file, independent of hook trust, so
  * cloning a repo carries zero memory trust (C.29 supply-chain safety). */
 export const MEMORY_TRUST_FILE_NAME = "memory-trust.json";
+/**
+ * Usage telemetry + cost tracking (C.22). Per-run/per-session usage records live
+ * in the GLOBAL dir only (`~/.cruxy/usage/runs.json`), `0600` — LOCAL accounting
+ * of your own usage, never transmitted. Pure data, validated, never eval'd.
+ */
+export const USAGE_DIR_NAME = "usage";
+export const USAGE_FILE_NAME = "runs.json";
 /**
  * Absolute path of the shipped builtin skills directory (`<pkg>/skills`).
  * Anchored the same way as the package.json lookup above: both `dist/` and

package/dist/errors/constructors.d.ts

@@ -150,6 +150,13 @@ export declare function memorySecretRefused(kind: string): CruxyError;
 export declare function memoryUntrusted(root: string): CruxyError;
 /** A malformed memory entry was rejected (C.29) — excluded, never eval'd. */
 export declare function memoryInvalid(detail: string): CruxyError;
+/**
+ * The local usage store (`~/.cruxy/usage/runs.json`) is corrupt or unreadable
+ * (C.22). Never fatal: usage accounting is best-effort, so the read is SKIPPED
+ * and this is surfaced. The fix is always to reset the file — its only content
+ * is your own local usage history, so deleting it loses nothing but history.
+ */
+export declare function usageRead(path: string, reason: string, underlying?: unknown): CruxyError;
 export declare function internal(underlying?: unknown): CruxyError;
 /**
  * Map a known provider/transport error (from `@cruxy/sdk`) to a typed

package/dist/errors/constructors.js

@@ -647,6 +647,25 @@ export function memoryInvalid(detail) {
         ],
     });
 }
+// ── usage telemetry (exit 2) — C.22 ───────────────────────────────────────────
+/**
+ * The local usage store (`~/.cruxy/usage/runs.json`) is corrupt or unreadable
+ * (C.22). Never fatal: usage accounting is best-effort, so the read is SKIPPED
+ * and this is surfaced. The fix is always to reset the file — its only content
+ * is your own local usage history, so deleting it loses nothing but history.
+ */
+export function usageRead(path, reason, underlying) {
+    return new CruxyError({
+        code: ErrorCode.UsageRead,
+        title: "could not read the local usage store",
+        cause: reason,
+        nextSteps: [
+            `delete ${path} to reset it (it holds only your local usage history)`,
+        ],
+        underlying,
+        meta: { path },
+    });
+}
 // ── internal (exit 1) ─────────────────────────────────────────────────────────
 export function internal(underlying) {
     return new CruxyError({

package/dist/errors/types.d.ts

@@ -80,6 +80,9 @@ export declare const ErrorCode: {
     /** A memory write was refused because the content matched a secret shape —
      * secrets are never persisted (defense in depth over C.17). */
     readonly MemorySecret: "CRUXY_E_MEMORY_SECRET";
+    /** The local usage store is corrupt/unreadable — the read is SKIPPED and this
+     * is surfaced; never fatal to a run (usage display is best-effort). */
+    readonly UsageRead: "CRUXY_E_USAGE_READ";
 };
 export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
 /** The process exit code for an error code (defaults to 1 for safety). */

package/dist/errors/types.js

@@ -95,6 +95,10 @@ export const ErrorCode = {
     /** A memory write was refused because the content matched a secret shape —
      * secrets are never persisted (defense in depth over C.17). */
     MemorySecret: "CRUXY_E_MEMORY_SECRET",
+    // usage telemetry (exit 2) — C.22
+    /** The local usage store is corrupt/unreadable — the read is SKIPPED and this
+     * is surfaced; never fatal to a run (usage display is best-effort). */
+    UsageRead: "CRUXY_E_USAGE_READ",
 };
 /**
  * Category exit codes. Distinct per category so a caller (CI, a script) can
@@ -162,6 +166,10 @@ const EXIT_CODES = {
     [ErrorCode.MemoryInvalid]: 14,
     [ErrorCode.MemoryUntrusted]: 14,
     [ErrorCode.MemorySecret]: 14,
+    // Usage telemetry (C.22). A corrupt store is a usage/data problem the user can
+    // fix (delete the file); it shares the usage exit code and is never fatal to a
+    // run — the aggregation just skips it.
+    [ErrorCode.UsageRead]: 2,
 };
 /** The process exit code for an error code (defaults to 1 for safety). */
 export function exitCodeFor(code) {

package/dist/plan/service.d.ts

@@ -1,4 +1,4 @@
-import type { Message, Provider } from "@cruxy/sdk";
+import type { Message, Provider, Usage } from "@cruxy/sdk";
 import type { CruxyConfig } from "../config/index.js";
 import type { PromptIO } from "../approval/index.js";
 import { ToolRegistry, type ToolContext } from "../tools/index.js";
@@ -45,5 +45,14 @@ export interface PlanSessionArgs {
      * and step execution on `main-turn`; omitted → the provider default.
      */
     router?: Router;
+    /**
+     * Usage telemetry (C.22): forwarded to every model request the plan turn
+     * drives (propose + each execution step), so plan-mode usage is captured and
+     * tier-attributed exactly like a normal turn.
+     */
+    onRequestUsage?: (req: {
+        tier?: string;
+        usage?: Usage;
+    }) => void;
 }
 export declare function runPlanSession(args: PlanSessionArgs): Promise<AgentResult>;

package/dist/plan/service.js

@@ -78,6 +78,7 @@ export async function runPlanSession(args) {
             planMode: true,
             router: args.router,
             taskClass: "plan",
+            onRequestUsage: args.onRequestUsage,
         }));
         if (!holder.plan) {
             throw planInvalid("the model ended its turn without calling submit_plan");
@@ -112,6 +113,7 @@ export async function runPlanSession(args) {
                     renderer: args.renderer,
                     router: args.router,
                     taskClass: "main-turn",
+                    onRequestUsage: args.onRequestUsage,
                 }));
             };
             await executePlan(plan, {

package/dist/usage/collect.d.ts

@@ -0,0 +1,40 @@
+import type { Usage } from "@cruxy/sdk";
+import type { UsageRecord } from "./types.js";
+/**
+ * Usage collection (C.22). Accumulates per-request usage exactly as the agent
+ * loop reports it — one {@link UsageEntry} per completed model request — and
+ * emits a {@link UsageRecord} for the run.
+ *
+ * The one honesty invariant: `usage: undefined` (the loop's signal that the
+ * provider returned NO usage event for a request) is recorded as `undefined`
+ * token counts — the honest "unknown". A provider-reported `0` arrives as a real
+ * `Usage` and is stored as `0`. Nothing is estimated, re-tokenized, or
+ * zero-filled, and this module makes ZERO network calls.
+ */
+/** What the loop hands over for one completed request. */
+export interface RequestUsage {
+    /** The routing tier (C.30) the request ran on, if routing was active. */
+    tier?: string;
+    /**
+     * The provider's usage for THIS request, or `undefined` when the provider
+     * emitted no usage event (⇒ tokens are unknown, not zero).
+     */
+    usage?: Usage;
+}
+/** Wall clock as an injectable seam so tests are deterministic. */
+export type Clock = () => string;
+export declare class UsageCollector {
+    private readonly now;
+    private readonly entries;
+    constructor(now?: Clock);
+    /**
+     * Record one completed request. When `req.usage` is absent the entry's token
+     * counts stay `undefined` — the provider reported nothing, so we assert
+     * nothing. A real reported `0` is preserved as `0`.
+     */
+    record(req: RequestUsage): void;
+    /** How many requests have been recorded so far. */
+    get count(): number;
+    /** Snapshot the collected entries into a persistable {@link UsageRecord}. */
+    toRecord(runId: string, sessionId: string | undefined, startedAt: string): UsageRecord;
+}

package/dist/usage/collect.js

@@ -0,0 +1,34 @@
+const systemClock = () => new Date().toISOString();
+export class UsageCollector {
+    now;
+    entries = [];
+    constructor(now = systemClock) {
+        this.now = now;
+    }
+    /**
+     * Record one completed request. When `req.usage` is absent the entry's token
+     * counts stay `undefined` — the provider reported nothing, so we assert
+     * nothing. A real reported `0` is preserved as `0`.
+     */
+    record(req) {
+        this.entries.push({
+            tier: req.tier,
+            inputTokens: req.usage?.input_tokens,
+            outputTokens: req.usage?.output_tokens,
+            at: this.now(),
+        });
+    }
+    /** How many requests have been recorded so far. */
+    get count() {
+        return this.entries.length;
+    }
+    /** Snapshot the collected entries into a persistable {@link UsageRecord}. */
+    toRecord(runId, sessionId, startedAt) {
+        return {
+            runId,
+            ...(sessionId !== undefined ? { sessionId } : {}),
+            startedAt,
+            entries: [...this.entries],
+        };
+    }
+}

package/dist/usage/cost.d.ts

@@ -0,0 +1,19 @@
+import type { PriceTable, TierPrice } from "./types.js";
+/**
+ * Token → cost mapping (C.22). The whole discipline lives in one rule: a cost is
+ * produced ONLY when the tier has a configured price AND at least one token side
+ * is known. Otherwise the result is `undefined` — cost is omitted, tokens are
+ * still shown, and NO dollar figure is ever fabricated. Prices are per MILLION
+ * tokens (see {@link TierPrice}). Keyed by tier only (U.8 gag). No network.
+ */
+/** The configured price for a tier, or `undefined` when the tier is unpriced. */
+export declare function priceForTier(tier: string, prices: PriceTable): TierPrice | undefined;
+/**
+ * Compute the cost of a tier's usage, or `undefined` when it cannot be stated
+ * honestly:
+ *  - no configured price for the tier → `undefined` (cost omitted).
+ *  - both token counts unknown → `undefined` (nothing real to price).
+ * A known side is priced; an unknown side contributes nothing (never a
+ * fabricated 0-token charge). tokens/1e6 × price, summed.
+ */
+export declare function costFor(tier: string, inputTokens: number | undefined, outputTokens: number | undefined, prices: PriceTable): number | undefined;

package/dist/usage/cost.js

@@ -0,0 +1,29 @@
+/**
+ * Token → cost mapping (C.22). The whole discipline lives in one rule: a cost is
+ * produced ONLY when the tier has a configured price AND at least one token side
+ * is known. Otherwise the result is `undefined` — cost is omitted, tokens are
+ * still shown, and NO dollar figure is ever fabricated. Prices are per MILLION
+ * tokens (see {@link TierPrice}). Keyed by tier only (U.8 gag). No network.
+ */
+/** The configured price for a tier, or `undefined` when the tier is unpriced. */
+export function priceForTier(tier, prices) {
+    return prices[tier];
+}
+/**
+ * Compute the cost of a tier's usage, or `undefined` when it cannot be stated
+ * honestly:
+ *  - no configured price for the tier → `undefined` (cost omitted).
+ *  - both token counts unknown → `undefined` (nothing real to price).
+ * A known side is priced; an unknown side contributes nothing (never a
+ * fabricated 0-token charge). tokens/1e6 × price, summed.
+ */
+export function costFor(tier, inputTokens, outputTokens, prices) {
+    const price = priceForTier(tier, prices);
+    if (!price)
+        return undefined;
+    if (inputTokens === undefined && outputTokens === undefined)
+        return undefined;
+    const inCost = inputTokens !== undefined ? (inputTokens / 1_000_000) * price.input : 0;
+    const outCost = outputTokens !== undefined ? (outputTokens / 1_000_000) * price.output : 0;
+    return inCost + outCost;
+}

package/dist/usage/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Usage telemetry + cost tracking (C.22) — LOCAL usage accounting only.
+ *
+ * NO-PHONE-HOME GUARANTEE: nothing here transmits anything. This module reads
+ * and writes ONE local file under `~/.cruxy/usage` and renders to the terminal;
+ * it imports no provider, no transport, and makes no `fetch`/HTTP call. The
+ * `@cruxy/sdk` import below is a TYPE-only import (`Usage`), erased at build. A
+ * future opt-in remote report would be a new, clearly-named seam — this build
+ * ships nothing that sends. Asserted by the runtime + static no-phone-home tests.
+ */
+export * from "./types.js";
+export { UsageCollector, type RequestUsage, type Clock } from "./collect.js";
+export { costFor, priceForTier } from "./cost.js";
+export { loadUsage, appendRun, usageStorePath } from "./store.js";
+export { summarizeRuns, renderSummary, formatCost, type SummarizeOptions, } from "./summary.js";

package/dist/usage/index.js

@@ -0,0 +1,15 @@
+/**
+ * Usage telemetry + cost tracking (C.22) — LOCAL usage accounting only.
+ *
+ * NO-PHONE-HOME GUARANTEE: nothing here transmits anything. This module reads
+ * and writes ONE local file under `~/.cruxy/usage` and renders to the terminal;
+ * it imports no provider, no transport, and makes no `fetch`/HTTP call. The
+ * `@cruxy/sdk` import below is a TYPE-only import (`Usage`), erased at build. A
+ * future opt-in remote report would be a new, clearly-named seam — this build
+ * ships nothing that sends. Asserted by the runtime + static no-phone-home tests.
+ */
+export * from "./types.js";
+export { UsageCollector } from "./collect.js";
+export { costFor, priceForTier } from "./cost.js";
+export { loadUsage, appendRun, usageStorePath } from "./store.js";
+export { summarizeRuns, renderSummary, formatCost, } from "./summary.js";