@cruxy/cli 0.18.0 → 0.20.0

package/dist/config/schema.d.ts

@@ -236,8 +236,8 @@ export declare const TestConfigSchema: z.ZodObject<{
     captureBytes: number;
     command?: string | undefined;
 }, {
-    maxIterations?: number | undefined;
     command?: string | undefined;
+    maxIterations?: number | undefined;
     captureBytes?: number | undefined;
 }>;
 /**
@@ -264,9 +264,9 @@ export declare const SubagentConfigSchema: z.ZodObject<{
         maxIterations: number;
         timeoutMs?: number | undefined;
     }, {
+        timeoutMs?: number | undefined;
         maxTokens?: number | undefined;
         maxIterations?: number | undefined;
-        timeoutMs?: number | undefined;
     }>>;
 }, "strict", z.ZodTypeAny, {
     maxDepth: number;
@@ -278,9 +278,9 @@ export declare const SubagentConfigSchema: z.ZodObject<{
 }, {
     maxDepth?: number | undefined;
     defaultBudget?: {
+        timeoutMs?: number | undefined;
         maxTokens?: number | undefined;
         maxIterations?: number | undefined;
-        timeoutMs?: number | undefined;
     } | undefined;
 }>;
 /**
@@ -408,6 +408,191 @@ export declare const MemoryConfigSchema: z.ZodObject<{
     maxRecallTokens?: number | undefined;
 }>;
 export type MemoryConfig = z.infer<typeof MemoryConfigSchema>;
+/**
+ * Per-language LSP integration (C.12): read-only, symbol-aware tools
+ * (find_definition, find_references, get_diagnostics, hover) backed by a
+ * managed pool of language servers. OFF by default — like the sandbox and
+ * hooks, it spawns and manages EXTERNAL server processes, a real execution
+ * surface the user opts into explicitly. When on, a missing server binary is
+ * an actionable, coded failure (CRUXY_E_LSP_SERVER_NOT_FOUND), never a silent
+ * empty result. Servers spawn lazily per language, are reused for the session,
+ * and are shut down cleanly (with a process-exit kill-tree backstop).
+ */
+export declare const LspConfigSchema: z.ZodObject<{
+    /** Master switch. When false, the four LSP tools are not registered and no
+     * server ever spawns (the feature stays fully inert). */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Per-language command overrides, keyed by language id (e.g. `typescript`,
+     * `python`, `go`, `rust`). The value is the full command line
+     * (`"gopls -remote=auto"`); it is split on whitespace. Anything omitted
+     * falls back to the built-in default table (see `lsp/registry.ts`).
+     */
+    servers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    /** Kill and fail (CRUXY_E_LSP_TIMEOUT) if the `initialize` handshake does
+     * not complete within this many ms. */
+    startupTimeout: z.ZodDefault<z.ZodNumber>;
+    /** Fail a single query (CRUXY_E_LSP_TIMEOUT) if the server does not respond
+     * within this many ms — the server is kept alive, only the request errors. */
+    requestTimeout: z.ZodDefault<z.ZodNumber>;
+    /** Maximum concurrently-running language servers; acquiring past the cap
+     * evicts the idle-oldest server first. */
+    maxServers: z.ZodDefault<z.ZodNumber>;
+    /** Shut a server down after it has been idle this many ms. */
+    idleTimeout: z.ZodDefault<z.ZodNumber>;
+    /** Cap on locations/diagnostics returned by a single tool call; the rest are
+     * summarized as an "N more" note (bounded output). */
+    maxResults: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    startupTimeout: number;
+    requestTimeout: number;
+    enabled: boolean;
+    servers: Record<string, string>;
+    maxServers: number;
+    idleTimeout: number;
+    maxResults: number;
+}, {
+    startupTimeout?: number | undefined;
+    requestTimeout?: number | undefined;
+    enabled?: boolean | undefined;
+    servers?: Record<string, string> | undefined;
+    maxServers?: number | undefined;
+    idleTimeout?: number | undefined;
+    maxResults?: number | undefined;
+}>;
+export type LspConfig = z.infer<typeof LspConfigSchema>;
+/** 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>;
@@ -415,12 +600,12 @@ export declare const McpServerSchema: z.ZodObject<{
     url: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     command?: string | undefined;
-    args?: string[] | undefined;
     url?: string | undefined;
+    args?: string[] | undefined;
 }, {
     command?: string | undefined;
-    args?: string[] | undefined;
     url?: string | undefined;
+    args?: string[] | undefined;
 }>;
 export declare const CruxyConfigSchema: z.ZodObject<{
     model: z.ZodDefault<z.ZodObject<{
@@ -610,6 +795,48 @@ export declare const CruxyConfigSchema: z.ZodObject<{
             overlapLines?: number | undefined;
         } | undefined;
     }>>;
+    lsp: z.ZodDefault<z.ZodObject<{
+        /** Master switch. When false, the four LSP tools are not registered and no
+         * server ever spawns (the feature stays fully inert). */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Per-language command overrides, keyed by language id (e.g. `typescript`,
+         * `python`, `go`, `rust`). The value is the full command line
+         * (`"gopls -remote=auto"`); it is split on whitespace. Anything omitted
+         * falls back to the built-in default table (see `lsp/registry.ts`).
+         */
+        servers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /** Kill and fail (CRUXY_E_LSP_TIMEOUT) if the `initialize` handshake does
+         * not complete within this many ms. */
+        startupTimeout: z.ZodDefault<z.ZodNumber>;
+        /** Fail a single query (CRUXY_E_LSP_TIMEOUT) if the server does not respond
+         * within this many ms — the server is kept alive, only the request errors. */
+        requestTimeout: z.ZodDefault<z.ZodNumber>;
+        /** Maximum concurrently-running language servers; acquiring past the cap
+         * evicts the idle-oldest server first. */
+        maxServers: z.ZodDefault<z.ZodNumber>;
+        /** Shut a server down after it has been idle this many ms. */
+        idleTimeout: z.ZodDefault<z.ZodNumber>;
+        /** Cap on locations/diagnostics returned by a single tool call; the rest are
+         * summarized as an "N more" note (bounded output). */
+        maxResults: z.ZodDefault<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        startupTimeout: number;
+        requestTimeout: number;
+        enabled: boolean;
+        servers: Record<string, string>;
+        maxServers: number;
+        idleTimeout: number;
+        maxResults: number;
+    }, {
+        startupTimeout?: number | undefined;
+        requestTimeout?: number | undefined;
+        enabled?: boolean | undefined;
+        servers?: Record<string, string> | undefined;
+        maxServers?: number | undefined;
+        idleTimeout?: number | undefined;
+        maxResults?: number | undefined;
+    }>>;
     checkpoint: z.ZodDefault<z.ZodObject<{
         /** Auto-checkpoint before a run's first mutation (and enable `cruxy rollback`). */
         enabled: z.ZodDefault<z.ZodBoolean>;
@@ -641,9 +868,9 @@ export declare const CruxyConfigSchema: z.ZodObject<{
             maxIterations: number;
             timeoutMs?: number | undefined;
         }, {
+            timeoutMs?: number | undefined;
             maxTokens?: number | undefined;
             maxIterations?: number | undefined;
-            timeoutMs?: number | undefined;
         }>>;
     }, "strict", z.ZodTypeAny, {
         maxDepth: number;
@@ -655,9 +882,9 @@ export declare const CruxyConfigSchema: z.ZodObject<{
     }, {
         maxDepth?: number | undefined;
         defaultBudget?: {
+            timeoutMs?: number | undefined;
             maxTokens?: number | undefined;
             maxIterations?: number | undefined;
-            timeoutMs?: number | undefined;
         } | undefined;
     }>>;
     test: z.ZodDefault<z.ZodObject<{
@@ -672,8 +899,8 @@ export declare const CruxyConfigSchema: z.ZodObject<{
         captureBytes: number;
         command?: string | undefined;
     }, {
-        maxIterations?: number | undefined;
         command?: string | undefined;
+        maxIterations?: number | undefined;
         captureBytes?: number | undefined;
     }>>;
     sandbox: z.ZodDefault<z.ZodObject<{
@@ -767,18 +994,128 @@ 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">>;
         url: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         command?: string | undefined;
-        args?: string[] | undefined;
         url?: string | undefined;
+        args?: string[] | undefined;
     }, {
         command?: string | undefined;
-        args?: string[] | undefined;
         url?: string | undefined;
+        args?: string[] | undefined;
     }>>>;
     logLevel: z.ZodDefault<z.ZodEnum<["debug", "info", "warn", "error", "silent"]>>;
 }, "strict", z.ZodTypeAny, {
@@ -789,6 +1126,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;
@@ -859,6 +1215,15 @@ export declare const CruxyConfigSchema: z.ZodObject<{
             overlapLines: number;
         };
     };
+    lsp: {
+        startupTimeout: number;
+        requestTimeout: number;
+        enabled: boolean;
+        servers: Record<string, string>;
+        maxServers: number;
+        idleTimeout: number;
+        maxResults: number;
+    };
     test: {
         maxIterations: number;
         captureBytes: number;
@@ -874,8 +1239,8 @@ export declare const CruxyConfigSchema: z.ZodObject<{
     };
     mcpServers: Record<string, {
         command?: string | undefined;
-        args?: string[] | undefined;
         url?: string | undefined;
+        args?: string[] | undefined;
     }>;
     logLevel: "debug" | "info" | "warn" | "error" | "silent";
 }, {
@@ -886,6 +1251,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;
@@ -906,9 +1290,9 @@ export declare const CruxyConfigSchema: z.ZodObject<{
     subagent?: {
         maxDepth?: number | undefined;
         defaultBudget?: {
+            timeoutMs?: number | undefined;
             maxTokens?: number | undefined;
             maxIterations?: number | undefined;
-            timeoutMs?: number | undefined;
         } | undefined;
     } | undefined;
     model?: {
@@ -956,9 +1340,18 @@ export declare const CruxyConfigSchema: z.ZodObject<{
             overlapLines?: number | undefined;
         } | undefined;
     } | undefined;
+    lsp?: {
+        startupTimeout?: number | undefined;
+        requestTimeout?: number | undefined;
+        enabled?: boolean | undefined;
+        servers?: Record<string, string> | undefined;
+        maxServers?: number | undefined;
+        idleTimeout?: number | undefined;
+        maxResults?: number | undefined;
+    } | undefined;
     test?: {
-        maxIterations?: number | undefined;
         command?: string | undefined;
+        maxIterations?: number | undefined;
         captureBytes?: number | undefined;
     } | undefined;
     hooks?: {
@@ -971,8 +1364,8 @@ export declare const CruxyConfigSchema: z.ZodObject<{
     } | undefined;
     mcpServers?: Record<string, {
         command?: string | undefined;
-        args?: string[] | undefined;
         url?: string | undefined;
+        args?: string[] | undefined;
     }> | undefined;
     logLevel?: "debug" | "info" | "warn" | "error" | "silent" | undefined;
 }>;

package/dist/config/schema.js

@@ -290,6 +290,81 @@ export const MemoryConfigSchema = z
     maxRecallTokens: z.number().int().positive().default(1000),
 })
     .strict();
+/**
+ * Per-language LSP integration (C.12): read-only, symbol-aware tools
+ * (find_definition, find_references, get_diagnostics, hover) backed by a
+ * managed pool of language servers. OFF by default — like the sandbox and
+ * hooks, it spawns and manages EXTERNAL server processes, a real execution
+ * surface the user opts into explicitly. When on, a missing server binary is
+ * an actionable, coded failure (CRUXY_E_LSP_SERVER_NOT_FOUND), never a silent
+ * empty result. Servers spawn lazily per language, are reused for the session,
+ * and are shut down cleanly (with a process-exit kill-tree backstop).
+ */
+export const LspConfigSchema = z
+    .object({
+    /** Master switch. When false, the four LSP tools are not registered and no
+     * server ever spawns (the feature stays fully inert). */
+    enabled: z.boolean().default(false),
+    /**
+     * Per-language command overrides, keyed by language id (e.g. `typescript`,
+     * `python`, `go`, `rust`). The value is the full command line
+     * (`"gopls -remote=auto"`); it is split on whitespace. Anything omitted
+     * falls back to the built-in default table (see `lsp/registry.ts`).
+     */
+    servers: z.record(z.string(), z.string().min(1)).default({}),
+    /** Kill and fail (CRUXY_E_LSP_TIMEOUT) if the `initialize` handshake does
+     * not complete within this many ms. */
+    startupTimeout: z.number().int().positive().default(15000),
+    /** Fail a single query (CRUXY_E_LSP_TIMEOUT) if the server does not respond
+     * within this many ms — the server is kept alive, only the request errors. */
+    requestTimeout: z.number().int().positive().default(10000),
+    /** Maximum concurrently-running language servers; acquiring past the cap
+     * evicts the idle-oldest server first. */
+    maxServers: z.number().int().positive().default(4),
+    /** Shut a server down after it has been idle this many ms. */
+    idleTimeout: z.number().int().positive().default(300000),
+    /** Cap on locations/diagnostics returned by a single tool call; the rest are
+     * summarized as an "N more" note (bounded output). */
+    maxResults: z.number().int().positive().default(100),
+})
+    .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({
@@ -309,6 +384,7 @@ export const CruxyConfigSchema = z
     context: ContextConfigSchema.default({}),
     approval: ApprovalConfigSchema.default({}),
     index: IndexConfigSchema.default({}),
+    lsp: LspConfigSchema.default({}),
     checkpoint: CheckpointConfigSchema.default({}),
     subagent: SubagentConfigSchema.default({}),
     test: TestConfigSchema.default({}),
@@ -316,6 +392,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