@juliantanx/aiusage 1.5.1 → 1.5.3

package/dist/index.js

@@ -8,19 +8,21 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 
 // src/cli.ts
 import { Command } from "commander";
-import { writeFileSync as writeFileSync6 } from "fs";
+import { writeFileSync as writeFileSync7 } from "fs";
 import { execSync as execSync5 } from "child_process";
 
 // src/commands/serve.ts
 import http2 from "http";
-import { readFileSync as readFileSync8, existsSync as existsSync9, statSync as statSync3, writeFileSync as writeFileSync5, unlinkSync as unlinkSync2 } from "fs";
-import { join as join10, extname as extname2, dirname as dirname3 } from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync10, statSync as statSync3, writeFileSync as writeFileSync6, unlinkSync as unlinkSync3 } from "fs";
+import { join as join11, extname as extname2, dirname as dirname4 } from "path";
 import { fileURLToPath } from "url";
 
 // src/api/server.ts
 import http from "http";
-import { hostname, platform as platform3 } from "os";
+import path2 from "path";
+import { hostname, platform as platform3, tmpdir } from "os";
 import { randomBytes as randomBytes3 } from "crypto";
+import { mkdtempSync, rmSync, writeFileSync as writeFileSync4 } from "fs";
 
 // ../core/dist/index.js
 import { createHash } from "crypto";
@@ -33,6 +35,7 @@ var TOOLS = [
   "qoder",
   "cursor",
   "kilocode",
+  "kelivo",
   "copilot",
   "gemini",
   "kimi",
@@ -109,204 +112,22 @@ async function fetchExchangeRate() {
 function convertToUSD(cny, rate) {
   return cny * rate;
 }
-var DEFAULT_PRICE_TABLE = {
-  // Anthropic — https://platform.claude.com/docs/en/about-claude/pricing
-  "claude-opus-4-8": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
-  "claude-opus-4-7": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
-  "claude-opus-4-6": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
-  "claude-opus-4-5": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
-  "claude-opus-4-1": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
-  "claude-sonnet-4-6": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
-  "claude-sonnet-4-5": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
-  "claude-haiku-4-5": { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
-  "claude-haiku-3-5": { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 },
-  "claude-sonnet-4": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
-  "claude-opus-4": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
-  "claude-3-5-sonnet": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
-  "claude-3-5-haiku": { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 },
-  // OpenAI — https://developers.openai.com/api/docs/pricing
-  "gpt-5.5-pro": { input: 30, output: 180 },
-  "gpt-5.5": { input: 5, output: 30, cacheRead: 0.5 },
-  "gpt-5.4-pro": { input: 30, output: 180 },
-  "gpt-5.4-mini": { input: 0.75, output: 4.5, cacheRead: 0.075 },
-  "gpt-5.4-nano": { input: 0.2, output: 1.25, cacheRead: 0.02 },
-  "gpt-5.4": { input: 2.5, output: 15, cacheRead: 0.25 },
-  "gpt-5.3-codex": { input: 1.75, output: 14, cacheRead: 0.175 },
-  "gpt-4o-mini": { input: 0.15, output: 0.6 },
-  "gpt-4o": { input: 2.5, output: 10 },
-  "gpt-4.1": { input: 2, output: 8 },
-  "o4-mini": { input: 1.1, output: 4.4 },
-  "o4-mini-deep-research": { input: 1, output: 4 },
-  "o3-pro": { input: 20, output: 80 },
-  "o3": { input: 2, output: 8 },
-  "o3-mini": { input: 0.55, output: 2.2, cacheRead: 0.55 },
-  "o3-deep-research": { input: 5, output: 20 },
-  "o1": { input: 15, output: 60, cacheRead: 7.5 },
-  "o1-mini": { input: 0.55, output: 2.2, cacheRead: 0.55 },
-  "codex-mini": { input: 0.75, output: 3, cacheRead: 0.025 },
-  "gpt-5.2-codex": { input: 1.75, output: 14, cacheRead: 0.175 },
-  "gpt-5.2": { input: 1.75, output: 14, cacheRead: 0.175 },
-  "gpt-5.1-codex": { input: 1.25, output: 10, cacheRead: 0.125 },
-  "gpt-5.1": { input: 1.25, output: 10, cacheRead: 0.125 },
-  "gpt-5-codex": { input: 1.25, output: 10, cacheRead: 0.125 },
-  "gpt-5": { input: 1.25, output: 10, cacheRead: 0.125 },
-  "gpt-5-mini": { input: 0.25, output: 2, cacheRead: 0.025 },
-  "gpt-5-nano": { input: 0.05, output: 0.4, cacheRead: 5e-3 },
-  "gpt-4.1-mini": { input: 0.4, output: 1.6, cacheRead: 0.1 },
-  "gpt-4.1-nano": { input: 0.1, output: 0.4, cacheRead: 0.025 },
-  // Google Gemini — https://ai.google.dev/gemini-api/docs/pricing
-  "gemini-3.5-flash": { input: 1.5, output: 9 },
-  "gemini-3.1-pro": { input: 2, output: 12 },
-  "gemini-3.1-flash-lite": { input: 0.25, output: 1.5 },
-  "gemini-3-pro-preview": { input: 2, output: 12 },
-  "gemini-3-flash-preview": { input: 0.5, output: 3 },
-  "gemini-3-flash": { input: 0.5, output: 3 },
-  "gemini-3-pro-image": { input: 2, output: 12 },
-  "gemini-3.1-pro-preview": { input: 2, output: 12 },
-  "gemini-3.1-flash-lite-preview": { input: 0.25, output: 1.5 },
-  "gemini-2.5-pro": { input: 1.25, output: 10 },
-  "gemini-2.5-flash-lite": { input: 0.1, output: 0.4 },
-  "gemini-2.5-flash": { input: 0.3, output: 2.5 },
-  "gemini-2.0-flash-lite": { input: 0.075, output: 0.3 },
-  "gemini-2.0-flash": { input: 0.1, output: 0.4 },
-  // DeepSeek — https://api-docs.deepseek.com/quick_start/pricing
-  "deepseek-v4-pro": { input: 3.13, output: 6.26, cacheRead: 0.026, currency: "CNY" },
-  "deepseek-v4-flash": { input: 1.01, output: 2.02, cacheRead: 0.02, currency: "CNY" },
-  "deepseek-v3.2": { input: 2.01, output: 3.01, cacheRead: 0.2, currency: "CNY" },
-  "deepseek-v3.1": { input: 3.94, output: 11.9, cacheRead: 0.39, currency: "CNY" },
-  "deepseek-v3": { input: 2.01, output: 7.94, cacheRead: 0.2, currency: "CNY" },
-  "deepseek-reasoner": { input: 3.94, output: 15.6, cacheRead: 1, currency: "CNY" },
-  "deepseek-chat": { input: 1.93, output: 7.87, cacheRead: 0.5, currency: "CNY" },
-  // Kimi (Moonshot AI) — https://platform.kimi.ai/docs/pricing/chat
-  "kimi-k2.6": { input: 6.9, output: 29, cacheRead: 1.15, currency: "CNY" },
-  "kimi-k2.5": { input: 4.3, output: 21.6, cacheRead: 0.72, currency: "CNY" },
-  "kimi-k2-turbo": { input: 8.3, output: 57.6, cacheRead: 1.08, currency: "CNY" },
-  "kimi-k2": { input: 4.3, output: 18, cacheRead: 1.08, currency: "CNY" },
-  "kimi-k2-thinking": { input: 3.94, output: 15.7, cacheRead: 0.71, currency: "CNY" },
-  "kimi-k2-0905": { input: 3.94, output: 15.7, cacheRead: 0.71, currency: "CNY" },
-  "moonshot-v1-128k": { input: 14.4, output: 36, currency: "CNY" },
-  "moonshot-v1-32k": { input: 7.2, output: 21.6, currency: "CNY" },
-  "moonshot-v1-8k": { input: 1.44, output: 14.4, currency: "CNY" },
-  // GLM (Z.ai / Zhipu AI) — https://docs.z.ai/guides/overview/pricing — TODO: verify against official pricing
-  "glm-5.1": { input: 10, output: 32, currency: "CNY" },
-  "glm-5p1": { input: 10, output: 32, currency: "CNY" },
-  // Fireworks alias (accounts/fireworks/models/glm-5p1)
-  "glm-5-turbo": { input: 8.5, output: 29, currency: "CNY" },
-  "glm-5": { input: 7, output: 23, currency: "CNY" },
-  "glm-4.7-flashx": { input: 0.5, output: 2.8, currency: "CNY" },
-  "glm-4.7": { input: 4, output: 16, currency: "CNY" },
-  "glm-4.6": { input: 4, output: 16, currency: "CNY" },
-  "glm-4.5-x": { input: 16, output: 64, currency: "CNY" },
-  "glm-4.5-airx": { input: 8, output: 32, currency: "CNY" },
-  "glm-4.5-air": { input: 1.4, output: 8, currency: "CNY" },
-  "glm-4.5": { input: 4, output: 16, currency: "CNY" },
-  // Qwen (Alibaba Cloud) — https://www.alibabacloud.com/help/en/model-studio/model-pricing
-  "qwen3.6-plus": { input: 2, output: 12, currency: "CNY" },
-  "qwen3-235b": { input: 5, output: 20, currency: "CNY" },
-  "qwen3-32b": { input: 1.12, output: 4.48, currency: "CNY" },
-  "qwen3-30b": { input: 1.4, output: 5.6, currency: "CNY" },
-  "qwen-max": { input: 11.5, output: 46, currency: "CNY" },
-  "qwen-plus": { input: 2.8, output: 8.4, currency: "CNY" },
-  "qwen-turbo": { input: 0.35, output: 1.4, currency: "CNY" },
-  "qwen-long": { input: 0.5, output: 2, currency: "CNY" },
-  "qwen2.5-72b": { input: 10, output: 40, currency: "CNY" },
-  "qwen2.5-7b": { input: 1.26, output: 5.04, currency: "CNY" },
-  "qwen3.5-plus": { input: 1.86, output: 11.2, currency: "CNY" },
-  "qwen3-max": { input: 5.59, output: 27.9, currency: "CNY" },
-  "qwen3-235b-a22b": { input: 5.01, output: 60.1, currency: "CNY" },
-  "qwen3-coder-plus": { input: 4.65, output: 23.3, currency: "CNY" },
-  "qwen3-coder-flash": { input: 1.4, output: 6.98, currency: "CNY" },
-  "qwen3-coder-next": { input: 0.86, output: 5.37, currency: "CNY" },
-  "qwq-plus": { input: 5.73, output: 17.2, currency: "CNY" },
-  "qwq-32b": { input: 1.43, output: 4.3, currency: "CNY" },
-  // Xiaomi MiMo — https://platform.xiaomimimo.com/docs/zh-CN/pricing
-  "mimo-v2.5-pro": { input: 3, output: 6, cacheRead: 0.025, currency: "CNY" },
-  "mimo-v2.5": { input: 1, output: 2, cacheRead: 0.02, currency: "CNY" },
-  "mimo-v2-flash": { input: 0.64, output: 2.08, cacheRead: 0.064, currency: "CNY" },
-  "mimo-v2-pro": { input: 7.17, output: 21.5, currency: "CNY" },
-  // MiniMax — https://platform.minimaxi.com/docs/guides/pricing-paygo
-  "minimax-m2.7": { input: 2.15, output: 8.59, cacheRead: 0.43, cacheWrite: 2.68, currency: "CNY" },
-  "minimax-m2.7-highspeed": { input: 4.3, output: 17.2, cacheRead: 0.43, cacheWrite: 2.68, currency: "CNY" },
-  "minimax-m2.5-lightning": { input: 2.15, output: 17.2, cacheRead: 0.21, currency: "CNY" },
-  "minimax-m2.5": { input: 0.86, output: 6.81, cacheRead: 0.21, currency: "CNY" },
-  "minimax-m2.1": { input: 1.93, output: 6.81, cacheRead: 0.21, currency: "CNY" },
-  "minimax-m2.1-lightning": { input: 1.93, output: 16.7, cacheRead: 0.21, currency: "CNY" },
-  "minimax-m2": { input: 1.93, output: 6.81, cacheRead: 0.21, currency: "CNY" },
-  // Mistral AI — https://mistral.ai/pricing
-  "mistral-large": { input: 0.5, output: 1.5 },
-  "mistral-large-3": { input: 0.5, output: 1.5 },
-  "mistral-medium": { input: 1.5, output: 7.5 },
-  "mistral-small": { input: 0.1, output: 0.3 },
-  "magistral-medium": { input: 2, output: 5 },
-  "magistral-small": { input: 0.5, output: 1.5 },
-  "devstral-medium": { input: 0.4, output: 2 },
-  "devstral-small": { input: 0.1, output: 0.3 },
-  "codestral": { input: 0.3, output: 0.9 },
-  "open-mistral-nemo": { input: 0.15, output: 0.15 },
-  "open-mixtral-8x22b": { input: 2, output: 6 },
-  "ministral-14b": { input: 0.2, output: 0.2 },
-  "ministral-8b": { input: 0.15, output: 0.15 },
-  "ministral-3b": { input: 0.1, output: 0.1 },
-  "pixtral-12b": { input: 0.1, output: 0.1 },
-  // xAI Grok — https://docs.x.ai/developers/models
-  "grok-4-1-fast": { input: 0.2, output: 0.5 },
-  "grok-4.3": { input: 1.25, output: 2.5 },
-  "grok-4.20-0309-reasoning": { input: 2, output: 6 },
-  "grok-4.20-0309-non-reasoning": { input: 2, output: 6 },
-  "grok-4": { input: 1.25, output: 2.5 },
-  "grok-build-0.1": { input: 1, output: 2 },
-  "grok-3": { input: 3, output: 15 },
-  "grok-3-mini": { input: 0.25, output: 0.5 },
-  // Cohere — https://cohere.com/pricing
-  "command-a": { input: 2.5, output: 10 },
-  "command-r-plus": { input: 2.5, output: 10 },
-  "command-r": { input: 0.15, output: 0.6 },
-  // Doubao (ByteDance) — https://www.volcengine.com/docs/82379/1544106
-  "doubao-seed-code": { input: 1.22, output: 7.95, currency: "CNY" },
-  "doubao-seed-2.0-pro": { input: 3.7, output: 18.5, currency: "CNY" },
-  "doubao-seed-2.0-code": { input: 3.36, output: 16.8, currency: "CNY" },
-  "doubao-seed-2.0-lite": { input: 0.63, output: 3.78, currency: "CNY" },
-  "doubao-seed-2.0-mini": { input: 0.21, output: 2.1, currency: "CNY" },
-  "doubao-seed-1.6-flash": { input: 0.16, output: 1.58, currency: "CNY" },
-  "doubao-seed-1.6-lite": { input: 0.32, output: 2.52, currency: "CNY" },
-  "doubao-seed-1.6": { input: 0.84, output: 8.4, currency: "CNY" },
-  "doubao-1.5-pro": { input: 0.84, output: 2.1, currency: "CNY" },
-  "doubao-1.5-lite": { input: 0.32, output: 0.63, currency: "CNY" },
-  // Hunyuan (Tencent) — https://cloud.tencent.com/document/product/1729 — TODO: verify against official pricing
-  "hunyuan-t1": { input: 0.48, output: 1.87, cacheRead: 0.21, currency: "CNY" },
-  "hunyuan-a13b": { input: 1, output: 4.1, currency: "CNY" },
-  // ERNIE (Baidu) — https://cloud.baidu.com/doc/WENXINWORKSHOP/s/Blfmc9dlf — TODO: verify against official pricing
-  "ernie-4.5-300b": { input: 2, output: 6.5, currency: "CNY" },
-  "ernie-4.5-21b": { input: 0.5, output: 2, currency: "CNY" },
-  "ernie-x1": { input: 2, output: 8, currency: "CNY" },
-  // StepFun (阶跃星辰)
-  "step-3.5-flash": { input: 0.72, output: 2.15, currency: "CNY" },
-  // Qoder credits — https://docs.qoder.com/user-guide/chat/model-tier-selector
-  // Qoder publishes credit multipliers and a $0.02 / credit pack price, but
-  // not a full per-token tariff. Estimate 1.0x as 1 credit / 10K tokens.
-  // Ultimate uses the current official limited-time 0.8x discount.
-  "qoder-auto": { input: 2, output: 2, cacheRead: 2, cacheWrite: 2 },
-  "qoder-ultimate": { input: 1.6, output: 1.6, cacheRead: 1.6, cacheWrite: 1.6 },
-  "qoder-performance": { input: 2.2, output: 2.2, cacheRead: 2.2, cacheWrite: 2.2 },
-  "qoder-efficient": { input: 0.6, output: 0.6, cacheRead: 0.6, cacheWrite: 0.6 },
-  "qoder-lite": { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }
-};
+var basePriceTable = {};
 var userOverrides = {};
-var PRICE_TABLE = { ...DEFAULT_PRICE_TABLE };
-function getPriceTable() {
-  return { ...DEFAULT_PRICE_TABLE, ...userOverrides };
+var PRICE_TABLE = {};
+function setRuntimePriceTable(base, overrides = {}) {
+  basePriceTable = { ...base };
+  userOverrides = { ...overrides };
+  PRICE_TABLE = { ...basePriceTable, ...userOverrides };
 }
 function setPriceOverride(model, entry) {
   userOverrides = { ...userOverrides, [model]: entry };
-  PRICE_TABLE = { ...DEFAULT_PRICE_TABLE, ...userOverrides };
+  PRICE_TABLE = { ...basePriceTable, ...userOverrides };
 }
 function removePriceOverride(model) {
   const { [model]: _, ...rest } = userOverrides;
   userOverrides = rest;
-  PRICE_TABLE = { ...DEFAULT_PRICE_TABLE, ...userOverrides };
-}
-function getUserOverrides() {
-  return { ...userOverrides };
+  PRICE_TABLE = { ...basePriceTable, ...userOverrides };
 }
 var PROVIDER_PREFIXES = [
   "accounts/fireworks/models/",
@@ -363,6 +184,15 @@ function calculateCostWithResolver(model, tokens, exchangeRate, resolver) {
 function calculateCost(model, tokens, exchangeRate) {
   return calculateCostWithResolver(model, tokens, exchangeRate, resolvePrice);
 }
+function calculateCostForPrice(price, tokens, exchangeRate) {
+  const inputCost = tokens.inputTokens / 1e6 * price.input;
+  const outputCost = tokens.outputTokens / 1e6 * price.output;
+  const cacheReadCost = tokens.cacheReadTokens / 1e6 * (price.cacheRead ?? 0);
+  const cacheWriteCost = tokens.cacheWriteTokens / 1e6 * (price.cacheWrite ?? 0);
+  const thinkingCost = tokens.thinkingTokens / 1e6 * price.output;
+  const rawCost = inputCost + outputCost + cacheReadCost + cacheWriteCost + thinkingCost;
+  return price.currency === "CNY" ? convertToUSD(rawCost, exchangeRate ?? FALLBACK_RATE) : rawCost;
+}
 var QODER_TIER_MODELS = /* @__PURE__ */ new Set([
   "auto",
   "ultimate",
@@ -1048,14 +878,14 @@ function usageFromAny(parsed) {
   const cachedFromDetails = num(details.cached_tokens);
   const rawInput = usage.input_tokens ?? usage.input ?? usage.prompt_tokens ?? usage.input_other ?? usage.tokensIn ?? 0;
   const cacheRead = num(
-    usage.cache_read_input_tokens ?? usage.cache_read_tokens ?? usage.input_cache_read ?? usage.cacheReads ?? cachedFromDetails
+    usage.cache_read_input_tokens ?? usage.cache_read_tokens ?? usage.input_cache_read ?? usage.cacheReads ?? usage.cacheRead ?? cachedFromDetails
   );
   return {
     inputTokens: Math.max(0, num(rawInput) - cachedFromDetails),
     outputTokens: num(usage.output_tokens ?? usage.output ?? usage.completion_tokens ?? usage.tokensOut),
     cacheReadTokens: cacheRead,
     cacheWriteTokens: num(
-      usage.cache_creation_input_tokens ?? usage.cache_write_input_tokens ?? usage.cache_write_tokens ?? usage.input_cache_creation ?? usage.cacheWrites
+      usage.cache_creation_input_tokens ?? usage.cache_write_input_tokens ?? usage.cache_write_tokens ?? usage.input_cache_creation ?? usage.cacheWrites ?? usage.cacheWrite
     ),
     thinkingTokens: num(
       usage.thinking_tokens ?? usage.reasoning_tokens ?? usage.reasoning_output_tokens ?? details.reasoning_tokens
@@ -1199,8 +1029,8 @@ var Aggregator = class {
 };
 
 // src/config.ts
-import { readFileSync, writeFileSync, existsSync } from "fs";
-import { join } from "path";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
 import { homedir } from "os";
 var AIUSAGE_DIR = join(homedir(), ".aiusage");
 var CONFIG_PATH = join(AIUSAGE_DIR, "config.json");
@@ -1230,6 +1060,7 @@ function loadConfig() {
   }
 }
 function saveConfig(config) {
+  mkdirSync(dirname(CONFIG_PATH), { recursive: true, mode: 448 });
   writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 384 });
 }
 function buildConsentConfig(config) {
@@ -1257,7 +1088,7 @@ function loadCredential(key) {
 }
 
 // src/init.ts
-import { mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
 import { join as join2 } from "path";
 import { randomUUID } from "crypto";
 function getState(aiusageDir) {
@@ -1720,6 +1551,13 @@ function probeKiloTasks(ctx) {
   }
   return null;
 }
+function probeKelivo(ctx) {
+  const override = envOverride("kelivo", ctx.env);
+  if (override) return override;
+  const legacy = ctx.legacySources?.["kelivo"];
+  if (legacy) return legacy;
+  return null;
+}
 function probeCopilot(ctx) {
   const override = envOverride("copilot", ctx.env);
   if (override) return override;
@@ -1905,6 +1743,7 @@ var TOOL_REGISTRY = [
   { tool: "cursor", sourceKey: "cursor", label: "Cursor", probe: probeCursor },
   { tool: "kilocode", sourceKey: "kilocode", label: "Kilo Code (extension)", probe: probeKiloTasks },
   { tool: "kilocode", sourceKey: "kilocode-db", label: "KiloCode", probe: probeKiloDb },
+  { tool: "kelivo", sourceKey: "kelivo", label: "Kelivo", probe: probeKelivo },
   { tool: "copilot", sourceKey: "copilot", label: "Copilot", probe: probeCopilot },
   { tool: "gemini", sourceKey: "gemini", label: "Gemini CLI", probe: probeGemini },
   { tool: "kimi", sourceKey: "kimi", label: "Kimi Code", probe: probeKimi },
@@ -1926,11 +1765,11 @@ function discoverTools(env = process.env) {
   const legacySources = config?.sources;
   const ctx = { home, env, legacySources };
   return TOOL_REGISTRY.map((entry) => {
-    const path2 = entry.probe(ctx);
-    if (!path2) {
+    const path3 = entry.probe(ctx);
+    if (!path3) {
       return { tool: entry.tool, sourceKey: entry.sourceKey, label: entry.label, path: "", fileCount: 0, status: "not_found" };
     }
-    const detectedPaths = entry.sourceKey === "opencode" && !envOverride("opencode", env) && !env.OPENCODE_DB && !legacySources?.["opencode"] ? existingOpenCodeDbs(env).filter((dbPath) => existsSync3(dbPath)) : entry.sourceKey === "codex" ? codexLogDirs(ctx, path2) : [path2];
+    const detectedPaths = entry.sourceKey === "opencode" && !envOverride("opencode", env) && !env.OPENCODE_DB && !legacySources?.["opencode"] ? existingOpenCodeDbs(env).filter((dbPath) => existsSync3(dbPath)) : entry.sourceKey === "codex" ? codexLogDirs(ctx, path3) : [path3];
     let fileCount = 0;
     for (const detectedPath of detectedPaths) {
       try {
@@ -1938,6 +1777,8 @@ function discoverTools(env = process.env) {
         if (stat2.isDirectory()) {
           if (entry.sourceKey === "roocode" || entry.sourceKey === "kilocode") {
             fileCount += findJsonFiles(detectedPath).filter((p) => basename(p) === "ui_messages.json").length;
+          } else if (entry.sourceKey === "kelivo") {
+            fileCount += findJsonFiles(detectedPath).filter((p) => basename(p) === "chats.json").length + findZipFiles(detectedPath).length;
           } else if (entry.sourceKey === "kiro") {
             fileCount += unique([...findJsonlFiles(detectedPath), ...findJsonFiles(detectedPath)]).length;
           } else {
@@ -1955,7 +1796,7 @@ function discoverTools(env = process.env) {
       tool: entry.tool,
       sourceKey: entry.sourceKey,
       label: entry.label,
-      path: path2,
+      path: path3,
       paths: visiblePaths.length > 1 || entry.sourceKey === "codex" && visiblePaths.length > 0 ? visiblePaths : void 0,
       fileCount,
       status
@@ -2057,6 +1898,11 @@ function discoverLogFiles(env = process.env) {
     const paths = findJsonFiles(kilocodeTaskPath).filter((p) => basename(p) === "ui_messages.json");
     if (paths.length > 0) results.push({ tool: "kilocode", paths: unique(paths) });
   }
+  const kelivoPath = probeKelivo(ctx);
+  if (kelivoPath && existsSync3(kelivoPath)) {
+    const paths = statSync(kelivoPath).isDirectory() ? [...findJsonFiles(kelivoPath).filter((p) => basename(p) === "chats.json"), ...findZipFiles(kelivoPath)] : basename(kelivoPath) === "chats.json" || basename(kelivoPath).endsWith(".zip") ? [kelivoPath] : [];
+    if (paths.length > 0) results.push({ tool: "kelivo", paths: unique(paths) });
+  }
   return results;
 }
 function findJsonFiles(dir) {
@@ -2075,6 +1921,22 @@ function findJsonFiles(dir) {
   }
   return results;
 }
+function findZipFiles(dir) {
+  const results = [];
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join3(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...findZipFiles(fullPath));
+      } else if (entry.isFile() && extname(entry.name) === ".zip") {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return results;
+}
 function normalizeQoderPath(source) {
   const normalized = source.replace(/\\/g, "/").replace(/\/+$/, "");
   if (normalized.endsWith("/logs/sessions") || normalized.endsWith("/sessions") || normalized.endsWith("/segments")) {
@@ -2594,8 +2456,8 @@ function generateNonce() {
 function generateIdempotencyKey() {
   return randomBytes(16).toString("hex");
 }
-function buildCanonicalString(method, path2, bodyHash, timestamp, nonce, deviceId, idempotencyKey) {
-  return [method, path2, bodyHash, timestamp, nonce, deviceId, idempotencyKey].join("\n");
+function buildCanonicalString(method, path3, bodyHash, timestamp, nonce, deviceId, idempotencyKey) {
+  return [method, path3, bodyHash, timestamp, nonce, deviceId, idempotencyKey].join("\n");
 }
 function base64url(data) {
   const buf = typeof data === "string" ? Buffer.from(data) : data;
@@ -2606,14 +2468,14 @@ function sha256Buffer(data) {
 }
 
 // src/leaderboard/credentials.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, unlinkSync, existsSync as existsSync6, renameSync } from "fs";
-import { join as join5, dirname } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, unlinkSync, existsSync as existsSync6, renameSync } from "fs";
+import { join as join5, dirname as dirname2 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 var CREDENTIALS_FILE = join5(AIUSAGE_DIR, "leaderboard-credentials.json");
 function saveCredentials(creds) {
-  const dir = dirname(CREDENTIALS_FILE);
+  const dir = dirname2(CREDENTIALS_FILE);
   if (!existsSync6(dir)) {
-    mkdirSync2(dir, { recursive: true });
+    mkdirSync3(dir, { recursive: true });
   }
   const tmpFile = `${CREDENTIALS_FILE}.${randomBytes2(4).toString("hex")}.tmp`;
   try {
@@ -2668,8 +2530,8 @@ async function readJsonOrNull(response) {
   if (!contentType.includes("application/json")) return null;
   return response.json().catch(() => null);
 }
-function endpointUnavailableMessage(path2, status) {
-  return `Leaderboard API endpoint ${path2} is unavailable (HTTP ${status}). The site deployment is not routing this API request to the Node server.`;
+function endpointUnavailableMessage(path3, status) {
+  return `Leaderboard API endpoint ${path3} is unavailable (HTTP ${status}). The site deployment is not routing this API request to the Node server.`;
 }
 async function fetchLeaderboard(serverUrl, options = {}) {
   const params = new URLSearchParams();
@@ -2832,14 +2694,14 @@ async function fetchLeaderboardStatus(serverUrl) {
 
 // src/db/index.ts
 import Database from "better-sqlite3";
-import { mkdirSync as mkdirSync3 } from "fs";
-import { dirname as dirname2 } from "path";
+import { mkdirSync as mkdirSync4 } from "fs";
+import { dirname as dirname3 } from "path";
 
 // src/db/schema.ts
 function applyPragmas(db) {
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = ON");
-  db.pragma("busy_timeout = 5000");
+  db.pragma("busy_timeout = 30000");
 }
 function createReadonlyViews(db) {
   db.exec(`
@@ -3132,6 +2994,79 @@ function migrateV9(db) {
   `);
 }
 
+// src/db/migrations/v10.ts
+function migrateV10(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS model_prices (
+      model_key        TEXT PRIMARY KEY,
+      provider         TEXT NOT NULL DEFAULT '',
+      input            REAL NOT NULL,
+      output           REAL NOT NULL,
+      cache_read       REAL,
+      cache_write      REAL,
+      currency         TEXT NOT NULL DEFAULT 'USD',
+      source           TEXT NOT NULL DEFAULT 'manual',
+      source_model_id  TEXT,
+      source_url       TEXT,
+      origin           TEXT NOT NULL DEFAULT 'user',
+      status           TEXT NOT NULL DEFAULT 'active',
+      last_synced_at   INTEGER,
+      created_at       INTEGER NOT NULL,
+      updated_at       INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS model_price_aliases (
+      alias       TEXT PRIMARY KEY,
+      model_key   TEXT NOT NULL REFERENCES model_prices(model_key) ON DELETE CASCADE,
+      match_type  TEXT NOT NULL DEFAULT 'exact',
+      provider    TEXT NOT NULL DEFAULT '',
+      priority    INTEGER NOT NULL DEFAULT 100,
+      source      TEXT NOT NULL DEFAULT 'manual',
+      origin      TEXT NOT NULL DEFAULT 'user',
+      enabled     INTEGER NOT NULL DEFAULT 1,
+      created_at  INTEGER NOT NULL,
+      updated_at  INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_model_prices_origin ON model_prices(origin);
+    CREATE INDEX IF NOT EXISTS idx_model_prices_source ON model_prices(source);
+    CREATE INDEX IF NOT EXISTS idx_model_price_aliases_model ON model_price_aliases(model_key);
+
+    INSERT INTO schema_version (version) VALUES (10);
+  `);
+}
+
+// src/db/migrations/v11.ts
+function migrateV11(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS model_price_sync_baselines (
+      model_key        TEXT PRIMARY KEY,
+      provider         TEXT NOT NULL DEFAULT '',
+      input            REAL NOT NULL,
+      output           REAL NOT NULL,
+      cache_read       REAL,
+      cache_write      REAL,
+      currency         TEXT NOT NULL DEFAULT 'USD',
+      source           TEXT NOT NULL DEFAULT 'litellm',
+      source_model_id  TEXT,
+      source_url       TEXT,
+      last_synced_at   INTEGER NOT NULL,
+      updated_at       INTEGER NOT NULL
+    );
+
+    INSERT INTO model_price_sync_baselines (
+      model_key, provider, input, output, cache_read, cache_write, currency, source,
+      source_model_id, source_url, last_synced_at, updated_at
+    )
+    SELECT model_key, provider, input, output, cache_read, cache_write, currency, source,
+           source_model_id, source_url, COALESCE(last_synced_at, updated_at), updated_at
+    FROM model_prices
+    WHERE origin = 'builtin' AND source != 'manual';
+
+    INSERT INTO schema_version (version) VALUES (11);
+  `);
+}
+
 // src/db/migrations/index.ts
 var MIGRATIONS = [
   { version: 1, migrate: migrateV1 },
@@ -3142,7 +3077,9 @@ var MIGRATIONS = [
   { version: 6, migrate: migrateV6 },
   { version: 7, migrate: migrateV7 },
   { version: 8, migrate: migrateV8 },
-  { version: 9, migrate: migrateV9 }
+  { version: 9, migrate: migrateV9 },
+  { version: 10, migrate: migrateV10 },
+  { version: 11, migrate: migrateV11 }
 ];
 function runMigrations(db) {
   createSchemaVersionTable(db);
@@ -3159,14 +3096,592 @@ function runMigrations(db) {
   }
 }
 
+// src/pricing-registry.ts
+var LITELLM_PRICING_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
+function rowToPrice(row) {
+  return {
+    input: Number(row.input),
+    output: Number(row.output),
+    cacheRead: row.cache_read == null ? void 0 : Number(row.cache_read),
+    cacheWrite: row.cache_write == null ? void 0 : Number(row.cache_write),
+    currency: row.currency
+  };
+}
+function normalizeProvider(provider) {
+  return (provider ?? "").trim().toLowerCase();
+}
+function normalizeModelKey(sourceModelId) {
+  const trimmed = sourceModelId.trim();
+  const slash = trimmed.indexOf("/");
+  return slash > 0 ? trimmed.slice(slash + 1) : trimmed;
+}
+function aliasesFor(sourceModelId, modelKey) {
+  const aliases = /* @__PURE__ */ new Set([modelKey, sourceModelId]);
+  if (modelKey.startsWith("claude-")) aliases.add(modelKey.replace(/-\d{8}$/, ""));
+  return [...aliases].filter(Boolean);
+}
+function litellmEntryToPrice(sourceModelId, entry) {
+  if (entry.mode && entry.mode !== "chat" && entry.mode !== "completion" && entry.mode !== "responses") return null;
+  if (entry.input_cost_per_second != null || entry.output_cost_per_second != null) return null;
+  if (typeof entry.input_cost_per_token !== "number" || typeof entry.output_cost_per_token !== "number") return null;
+  const modelKey = normalizeModelKey(sourceModelId);
+  if (!modelKey || modelKey.includes("*")) return null;
+  return {
+    modelKey,
+    provider: normalizeProvider(entry.litellm_provider),
+    price: {
+      input: entry.input_cost_per_token * 1e6,
+      output: entry.output_cost_per_token * 1e6,
+      cacheRead: typeof entry.cache_read_input_token_cost === "number" ? entry.cache_read_input_token_cost * 1e6 : void 0,
+      cacheWrite: typeof entry.cache_creation_input_token_cost === "number" ? entry.cache_creation_input_token_cost * 1e6 : void 0,
+      currency: "USD"
+    }
+  };
+}
+function loadBuiltinRows(db) {
+  return db.prepare(`
+    SELECT model_key, provider, input, output, cache_read, cache_write, currency, source, source_model_id,
+           source_url, origin, status, last_synced_at, updated_at
+    FROM model_prices
+    WHERE origin = 'builtin' AND status = 'active'
+  `).all();
+}
+function loadUserRows(db) {
+  return db.prepare(`
+    SELECT model_key, provider, input, output, cache_read, cache_write, currency, source, source_model_id,
+           source_url, origin, status, last_synced_at, updated_at
+    FROM model_prices
+    WHERE origin = 'user' AND status = 'active'
+  `).all();
+}
+function loadSyncedBaselineRows(db) {
+  return db.prepare(`
+    SELECT model_key, provider, input, output, cache_read, cache_write, currency, source, source_model_id,
+           source_url, last_synced_at, updated_at
+    FROM model_price_sync_baselines
+  `).all();
+}
+function loadAliasRows(db) {
+  return db.prepare(`
+    SELECT alias, model_key, match_type, provider, priority, source, origin, enabled
+    FROM model_price_aliases
+    WHERE enabled = 1
+    ORDER BY priority ASC
+  `).all();
+}
+function loadPricingRuntime(db, config) {
+  const builtin = {};
+  for (const row of loadBuiltinRows(db)) builtin[row.model_key] = rowToPrice(row);
+  const overrides = {};
+  const userRows = loadUserRows(db);
+  const configOverrides = config?.priceOverrides ?? {};
+  const activePrices = priceTableFromDb(db);
+  for (const alias of loadAliasRows(db)) {
+    const price = activePrices[alias.model_key];
+    if (!price) continue;
+    if (alias.origin === "user") overrides[alias.alias] = price;
+    else builtin[alias.alias] = price;
+  }
+  for (const row of userRows) overrides[row.model_key] = rowToPrice(row);
+  for (const [model, entry] of Object.entries(configOverrides)) overrides[model] = entry;
+  setRuntimePriceTable(builtin, overrides);
+}
+function setUserPrice(db, modelKey, entry) {
+  const now = Date.now();
+  const baseline = db.prepare(`
+    SELECT provider, source, source_model_id, source_url, last_synced_at
+    FROM model_price_sync_baselines
+    WHERE model_key = ?
+  `).get(modelKey);
+  db.prepare(`
+    INSERT INTO model_prices (
+      model_key, provider, input, output, cache_read, cache_write, currency, source, source_model_id,
+      source_url, origin, status, last_synced_at, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, 'manual', ?, ?, 'user', 'active', ?, ?, ?)
+    ON CONFLICT(model_key) DO UPDATE SET
+      provider = excluded.provider,
+      input = excluded.input,
+      output = excluded.output,
+      cache_read = excluded.cache_read,
+      cache_write = excluded.cache_write,
+      currency = excluded.currency,
+      source = 'manual',
+      source_model_id = excluded.source_model_id,
+      source_url = excluded.source_url,
+      origin = 'user',
+      status = 'active',
+      last_synced_at = excluded.last_synced_at,
+      updated_at = excluded.updated_at
+  `).run(
+    modelKey,
+    baseline?.provider ?? "",
+    entry.input,
+    entry.output,
+    entry.cacheRead ?? null,
+    entry.cacheWrite ?? null,
+    entry.currency ?? "USD",
+    baseline?.source_model_id ?? modelKey,
+    baseline?.source_url ?? null,
+    baseline?.last_synced_at ?? null,
+    now,
+    now
+  );
+  setPriceOverride(modelKey, entry);
+}
+function resetUserPriceToSynced(db, modelKey) {
+  const baseline = db.prepare(`
+    SELECT model_key, provider, input, output, cache_read, cache_write, currency, source, source_model_id,
+           source_url, last_synced_at, updated_at
+    FROM model_price_sync_baselines
+    WHERE model_key = ?
+  `).get(modelKey);
+  if (!baseline) {
+    removeUserPrice(db, modelKey);
+    return;
+  }
+  const now = Date.now();
+  db.prepare("DELETE FROM model_price_aliases WHERE alias = ? AND model_key = ? AND origin = 'user'").run(modelKey, modelKey);
+  db.prepare(`
+    INSERT INTO model_prices (
+      model_key, provider, input, output, cache_read, cache_write, currency, source, source_model_id,
+      source_url, origin, status, last_synced_at, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'builtin', 'active', ?, ?, ?)
+    ON CONFLICT(model_key) DO UPDATE SET
+      provider = excluded.provider,
+      input = excluded.input,
+      output = excluded.output,
+      cache_read = excluded.cache_read,
+      cache_write = excluded.cache_write,
+      currency = excluded.currency,
+      source = excluded.source,
+      source_model_id = excluded.source_model_id,
+      source_url = excluded.source_url,
+      origin = 'builtin',
+      status = 'active',
+      last_synced_at = excluded.last_synced_at,
+      updated_at = excluded.updated_at
+  `).run(
+    baseline.model_key,
+    baseline.provider,
+    baseline.input,
+    baseline.output,
+    baseline.cache_read,
+    baseline.cache_write,
+    baseline.currency,
+    baseline.source,
+    baseline.source_model_id,
+    baseline.source_url,
+    baseline.last_synced_at,
+    now,
+    now
+  );
+}
+function setUserPricingAlias(db, alias, modelKey) {
+  const aliasKey = alias.trim();
+  const targetKey = modelKey.trim();
+  if (!aliasKey || !targetKey) throw new Error("alias and modelKey required");
+  const target = db.prepare(`
+    SELECT provider
+    FROM model_prices
+    WHERE model_key = ? AND status = 'active'
+  `).get(targetKey);
+  if (!target) throw new Error("Pricing model not found");
+  const now = Date.now();
+  db.prepare(`
+    INSERT INTO model_price_aliases (alias, model_key, match_type, provider, priority, source, origin, enabled, created_at, updated_at)
+    VALUES (?, ?, 'exact', ?, 200, 'manual', 'user', 1, ?, ?)
+    ON CONFLICT(alias) DO UPDATE SET
+      model_key = excluded.model_key,
+      match_type = 'exact',
+      provider = excluded.provider,
+      priority = excluded.priority,
+      source = 'manual',
+      origin = 'user',
+      enabled = 1,
+      updated_at = excluded.updated_at
+  `).run(aliasKey, targetKey, target.provider ?? "", now, now);
+}
+function removeUserPricingAlias(db, alias) {
+  const aliasKey = alias.trim();
+  if (!aliasKey) throw new Error("alias required");
+  db.prepare("DELETE FROM model_price_aliases WHERE alias = ? AND origin = 'user'").run(aliasKey);
+}
+function removeUserPrice(db, modelKey) {
+  db.prepare("DELETE FROM model_price_aliases WHERE alias = ? AND model_key = ? AND origin = 'user'").run(modelKey, modelKey);
+  db.prepare("DELETE FROM model_prices WHERE model_key = ? AND origin = 'user'").run(modelKey);
+}
+function upsertBuiltinPrice(db, entry, now) {
+  db.prepare(`
+    INSERT INTO model_price_sync_baselines (
+      model_key, provider, input, output, cache_read, cache_write, currency, source,
+      source_model_id, source_url, last_synced_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, 'litellm', ?, ?, ?, ?)
+    ON CONFLICT(model_key) DO UPDATE SET
+      provider = excluded.provider,
+      input = excluded.input,
+      output = excluded.output,
+      cache_read = excluded.cache_read,
+      cache_write = excluded.cache_write,
+      currency = excluded.currency,
+      source = excluded.source,
+      source_model_id = excluded.source_model_id,
+      source_url = excluded.source_url,
+      last_synced_at = excluded.last_synced_at,
+      updated_at = excluded.updated_at
+  `).run(
+    entry.modelKey,
+    entry.provider,
+    entry.price.input,
+    entry.price.output,
+    entry.price.cacheRead ?? null,
+    entry.price.cacheWrite ?? null,
+    entry.price.currency ?? "USD",
+    entry.sourceModelId,
+    entry.sourceUrl,
+    now,
+    now
+  );
+  const existing = db.prepare("SELECT origin, input, output, cache_read, cache_write, currency FROM model_prices WHERE model_key = ?").get(entry.modelKey);
+  if (existing?.origin === "user") return "user_preserved";
+  const next = [entry.price.input, entry.price.output, entry.price.cacheRead ?? null, entry.price.cacheWrite ?? null, entry.price.currency ?? "USD"];
+  if (!existing) {
+    db.prepare(`
+      INSERT INTO model_prices (
+        model_key, provider, input, output, cache_read, cache_write, currency, source, source_model_id,
+        source_url, origin, status, last_synced_at, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, 'litellm', ?, ?, 'builtin', 'active', ?, ?, ?)
+    `).run(entry.modelKey, entry.provider, ...next, entry.sourceModelId, entry.sourceUrl, now, now, now);
+    return "added";
+  }
+  const current = [Number(existing.input), Number(existing.output), existing.cache_read == null ? null : Number(existing.cache_read), existing.cache_write == null ? null : Number(existing.cache_write), existing.currency];
+  const changed = current.some((value, index) => value !== next[index]);
+  if (!changed) {
+    db.prepare(`
+      UPDATE model_prices SET provider = ?, source = 'litellm', source_model_id = ?, source_url = ?, last_synced_at = ?, updated_at = ?
+      WHERE model_key = ? AND origin = 'builtin'
+    `).run(entry.provider, entry.sourceModelId, entry.sourceUrl, now, now, entry.modelKey);
+    return "unchanged";
+  }
+  db.prepare(`
+    UPDATE model_prices
+    SET provider = ?, input = ?, output = ?, cache_read = ?, cache_write = ?, currency = ?, source = 'litellm',
+        source_model_id = ?, source_url = ?, status = 'active', last_synced_at = ?, updated_at = ?
+    WHERE model_key = ? AND origin = 'builtin'
+  `).run(entry.provider, ...next, entry.sourceModelId, entry.sourceUrl, now, now, entry.modelKey);
+  return "updated";
+}
+function upsertBuiltinAlias(db, alias, modelKey, provider, source, now) {
+  const existing = db.prepare("SELECT origin, model_key, enabled FROM model_price_aliases WHERE alias = ?").get(alias);
+  if (existing?.origin === "user") return "user_preserved";
+  if (!existing) {
+    db.prepare(`
+      INSERT INTO model_price_aliases (alias, model_key, match_type, provider, priority, source, origin, enabled, created_at, updated_at)
+      VALUES (?, ?, 'exact', ?, 100, ?, 'builtin', 1, ?, ?)
+    `).run(alias, modelKey, provider, source, now, now);
+    return "added";
+  }
+  if (existing.model_key === modelKey && existing.enabled === 1) return "unchanged";
+  db.prepare(`
+    UPDATE model_price_aliases SET model_key = ?, provider = ?, source = ?, enabled = 1, updated_at = ?
+    WHERE alias = ? AND origin = 'builtin'
+  `).run(modelKey, provider, source, now, alias);
+  return "updated";
+}
+async function syncPricingFromLitellm(db) {
+  const response = await fetch(LITELLM_PRICING_URL, { headers: { Accept: "application/json" } });
+  if (!response.ok) throw new Error(`LiteLLM pricing fetch failed: HTTP ${response.status}`);
+  const data = await response.json();
+  const now = Date.now();
+  const summary = {
+    source: "litellm",
+    added: 0,
+    updated: 0,
+    unchanged: 0,
+    skipped: 0,
+    aliasesAdded: 0,
+    aliasesUpdated: 0,
+    userPreserved: 0,
+    dryRun: { totalModels: 0, matched: 0, unresolved: [] }
+  };
+  const tx = db.transaction(() => {
+    for (const [sourceModelId, rawEntry] of Object.entries(data)) {
+      const parsed = litellmEntryToPrice(sourceModelId, rawEntry);
+      if (!parsed) {
+        summary.skipped++;
+        continue;
+      }
+      const result = upsertBuiltinPrice(db, {
+        modelKey: parsed.modelKey,
+        provider: parsed.provider,
+        price: parsed.price,
+        sourceModelId,
+        sourceUrl: LITELLM_PRICING_URL
+      }, now);
+      if (result === "user_preserved") summary.userPreserved++;
+      else summary[result]++;
+      for (const alias of aliasesFor(sourceModelId, parsed.modelKey)) {
+        const aliasResult = upsertBuiltinAlias(db, alias, parsed.modelKey, parsed.provider, "litellm", now);
+        if (aliasResult === "added") summary.aliasesAdded++;
+        else if (aliasResult === "updated") summary.aliasesUpdated++;
+        else if (aliasResult === "user_preserved") summary.userPreserved++;
+      }
+    }
+  });
+  tx();
+  summary.dryRun = dryRunLocalModels(db);
+  return summary;
+}
+function priceTableFromDb(db) {
+  const table = {};
+  const rows = db.prepare(`
+    SELECT model_key, input, output, cache_read, cache_write, currency
+    FROM model_prices WHERE status = 'active'
+  `).all();
+  for (const row of rows) table[row.model_key] = rowToPrice(row);
+  return table;
+}
+function resolvePriceFromRegistry(db, model) {
+  const directUserPrice = db.prepare(`
+    SELECT input, output, cache_read, cache_write, currency
+    FROM model_prices
+    WHERE model_key = ? AND origin = 'user' AND status = 'active'
+  `).get(model);
+  if (directUserPrice) return rowToPrice(directUserPrice);
+  const exactAlias = db.prepare(`
+    SELECT p.input, p.output, p.cache_read, p.cache_write, p.currency
+    FROM model_price_aliases a
+    JOIN model_prices p ON p.model_key = a.model_key
+    WHERE a.alias = ? AND a.enabled = 1 AND p.status = 'active'
+    ORDER BY a.priority DESC LIMIT 1
+  `).get(model);
+  if (exactAlias) return rowToPrice(exactAlias);
+  return resolvePriceFromTable(model, priceTableFromDb(db));
+}
+function findMatch(db, model) {
+  const directUserMatch = db.prepare(`
+    SELECT model_key, provider, input, output, cache_read, cache_write, currency, source, source_model_id,
+           source_url, origin, status, last_synced_at, updated_at
+    FROM model_prices
+    WHERE model_key = ? AND origin = 'user' AND status = 'active'
+  `).get(model);
+  if (directUserMatch) return { price: rowToPrice(directUserMatch), row: directUserMatch, matchedBy: null };
+  const aliasMatch = db.prepare(`
+    SELECT p.model_key, p.provider, p.input, p.output, p.cache_read, p.cache_write, p.currency, p.source,
+           p.source_model_id, p.source_url, p.origin, p.status, p.last_synced_at, p.updated_at, a.alias
+    FROM model_price_aliases a
+    JOIN model_prices p ON p.model_key = a.model_key
+    WHERE a.alias = ? AND a.enabled = 1 AND p.status = 'active'
+    ORDER BY a.priority DESC LIMIT 1
+  `).get(model);
+  if (aliasMatch) {
+    const matchedBy = aliasMatch.alias === model ? aliasMatch.model_key === model ? null : aliasMatch.model_key : aliasMatch.alias;
+    return { price: rowToPrice(aliasMatch), row: aliasMatch, matchedBy };
+  }
+  const rows = db.prepare(`
+    SELECT model_key, provider, input, output, cache_read, cache_write, currency, source, source_model_id,
+           source_url, origin, status, last_synced_at, updated_at
+    FROM model_prices WHERE status = 'active'
+  `).all();
+  let best = null;
+  for (const row of rows) {
+    if (model === row.model_key) {
+      best = row;
+      break;
+    }
+    if (model.startsWith(row.model_key) && (!best || row.model_key.length > best.model_key.length)) best = row;
+  }
+  if (!best) return null;
+  return { price: rowToPrice(best), row: best, matchedBy: best.model_key === model ? null : best.model_key };
+}
+function listPricingModels(db) {
+  const dbModels = db.prepare("SELECT model, COUNT(*) as usage_count FROM records WHERE model != 'unknown' GROUP BY model ORDER BY usage_count DESC, model ASC").all();
+  const knownModels = new Set(dbModels.map((row) => row.model));
+  const userRows = loadUserRows(db);
+  for (const row of userRows) knownModels.add(row.model_key);
+  const syncedBaselines = new Set(loadSyncedBaselineRows(db).map((row) => row.model_key));
+  return [...knownModels].map((model) => {
+    const match = findMatch(db, model);
+    if (!match) {
+      return {
+        model,
+        provider: null,
+        price: null,
+        currency: "USD",
+        origin: null,
+        source: null,
+        sourceModelId: null,
+        lastSyncedAt: null,
+        isBuiltin: false,
+        isOverride: false,
+        isDefault: false,
+        hasSyncedBaseline: syncedBaselines.has(model),
+        matchedBy: null
+      };
+    }
+    return {
+      model,
+      provider: match.row.provider || null,
+      price: match.price,
+      currency: match.price.currency ?? "USD",
+      origin: match.row.origin,
+      source: match.row.source,
+      sourceModelId: match.row.source_model_id,
+      lastSyncedAt: match.row.last_synced_at,
+      isBuiltin: match.row.origin === "builtin",
+      isOverride: match.row.origin === "user",
+      isDefault: match.row.origin === "builtin",
+      hasSyncedBaseline: syncedBaselines.has(match.row.model_key),
+      matchedBy: match.matchedBy
+    };
+  });
+}
+function getPricingRegistrySummary(db) {
+  const priceCounts = db.prepare(`
+    SELECT
+      COUNT(*) AS totalPrices,
+      SUM(CASE WHEN origin = 'builtin' THEN 1 ELSE 0 END) AS builtinPrices,
+      SUM(CASE WHEN origin = 'user' THEN 1 ELSE 0 END) AS userPrices,
+      MAX(last_synced_at) AS lastSyncedAt
+    FROM model_prices
+    WHERE status = 'active'
+  `).get();
+  const aliasCounts = db.prepare(`
+    SELECT COUNT(*) AS activeAliases
+    FROM model_price_aliases
+    WHERE enabled = 1
+  `).get();
+  const dryRun = dryRunLocalModels(db);
+  return {
+    totalPrices: Number(priceCounts.totalPrices ?? 0),
+    builtinPrices: Number(priceCounts.builtinPrices ?? 0),
+    userPrices: Number(priceCounts.userPrices ?? 0),
+    activeAliases: Number(aliasCounts.activeAliases ?? 0),
+    lastSyncedAt: priceCounts.lastSyncedAt == null ? null : Number(priceCounts.lastSyncedAt),
+    localModels: dryRun.totalModels,
+    matchedLocalModels: dryRun.matched,
+    unresolvedLocalModels: dryRun.unresolved
+  };
+}
+function listPricingAliasTargets(db) {
+  const rows = db.prepare(`
+    SELECT model_key, provider, origin, source, source_model_id, currency
+    FROM model_prices
+    WHERE status = 'active'
+    ORDER BY origin DESC, provider ASC, model_key ASC
+  `).all();
+  return rows.map((row) => ({
+    model: row.model_key,
+    provider: row.provider,
+    origin: row.origin,
+    source: row.source,
+    sourceModelId: row.source_model_id,
+    currency: row.currency
+  }));
+}
+function listLocalModelBindings(db) {
+  const rows = db.prepare("SELECT DISTINCT model FROM records WHERE model != 'unknown' ORDER BY model ASC").all();
+  const priceRows = db.prepare(`
+    SELECT model_key, provider, input, output, cache_read, cache_write, currency, source, source_model_id,
+           source_url, origin, status, last_synced_at, updated_at
+    FROM model_prices WHERE status = 'active'
+  `).all();
+  return rows.map(({ model }) => {
+    const directUserPrice = db.prepare(`
+      SELECT model_key, provider, input, output, cache_read, cache_write, currency, source, source_model_id,
+             source_url, origin, status, last_synced_at, updated_at
+      FROM model_prices
+      WHERE model_key = ? AND origin = 'user' AND status = 'active'
+    `).get(model);
+    const aliasMatch = db.prepare(`
+      SELECT a.alias, a.model_key AS modelKey, a.origin, a.source, p.origin AS priceOrigin
+      FROM model_price_aliases a
+      JOIN model_prices p ON p.model_key = a.model_key
+      WHERE a.alias = ? AND a.enabled = 1 AND p.status = 'active'
+      ORDER BY a.priority DESC LIMIT 1
+    `).get(model);
+    if (directUserPrice) {
+      const hasManualBinding = Boolean(aliasMatch && aliasMatch.origin === "user" && !(aliasMatch.alias === model && aliasMatch.modelKey === model));
+      return {
+        model,
+        modelKey: hasManualBinding ? aliasMatch.modelKey : directUserPrice.model_key,
+        origin: hasManualBinding ? aliasMatch.origin : directUserPrice.origin,
+        priceOrigin: directUserPrice.origin,
+        source: directUserPrice.source,
+        matchType: "exact",
+        bindingType: "custom",
+        hasManualBinding,
+        hasPrice: true
+      };
+    }
+    if (aliasMatch) {
+      const selfAlias = aliasMatch.alias === model && aliasMatch.modelKey === model;
+      const hasManualBinding = aliasMatch.origin === "user" && !selfAlias;
+      return {
+        model,
+        modelKey: aliasMatch.modelKey,
+        origin: aliasMatch.origin,
+        priceOrigin: aliasMatch.priceOrigin,
+        source: aliasMatch.source,
+        matchType: selfAlias ? "exact" : "alias",
+        bindingType: aliasMatch.priceOrigin === "user" ? "custom" : hasManualBinding ? "manual" : "automatic",
+        hasManualBinding,
+        hasPrice: true
+      };
+    }
+    let best = null;
+    let matchType = null;
+    for (const row of priceRows) {
+      if (model === row.model_key) {
+        best = row;
+        matchType = "exact";
+        break;
+      }
+      if (model.startsWith(row.model_key) && (!best || row.model_key.length > best.model_key.length)) {
+        best = row;
+        matchType = "prefix";
+      }
+    }
+    return {
+      model,
+      modelKey: best?.model_key ?? null,
+      origin: best?.origin ?? null,
+      priceOrigin: best?.origin ?? null,
+      source: best?.source ?? null,
+      matchType,
+      bindingType: best?.origin === "user" ? "custom" : best ? "automatic" : "none",
+      hasManualBinding: false,
+      hasPrice: Boolean(best)
+    };
+  });
+}
+function dryRunLocalModels(db) {
+  const models = db.prepare("SELECT DISTINCT model FROM records WHERE model != 'unknown' ORDER BY model ASC").all();
+  const unresolved = [];
+  let matched = 0;
+  for (const row of models) {
+    if (resolvePriceFromRegistry(db, row.model)) matched++;
+    else unresolved.push(row.model);
+  }
+  return { totalModels: models.length, matched, unresolved: unresolved.slice(0, 50) };
+}
+function getUserAliasBindings(db) {
+  return db.prepare(`
+    SELECT alias, model_key AS modelKey, origin, source
+    FROM model_price_aliases
+    WHERE origin = 'user' AND enabled = 1
+    ORDER BY alias ASC
+  `).all();
+}
+
 // src/db/index.ts
 function initializeDatabase(db) {
   applyPragmas(db);
   runMigrations(db);
+  loadPricingRuntime(db, loadConfig());
 }
-function createDatabase(path2) {
-  mkdirSync3(dirname2(path2), { recursive: true, mode: 448 });
-  const db = new Database(path2);
+function createDatabase(path3) {
+  mkdirSync4(dirname3(path3), { recursive: true, mode: 448 });
+  const db = new Database(path3);
   initializeDatabase(db);
   return db;
 }
@@ -3364,10 +3879,10 @@ function getClientPlatform() {
 }
 function getCliVersion() {
   try {
-    const { readFileSync: readFileSync11 } = __require("fs");
+    const { readFileSync: readFileSync12 } = __require("fs");
     const { join: join16 } = __require("path");
     const pkgPath = join16(__dirname, "../../package.json");
-    const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
     return "0.0.0";
@@ -3645,102 +4160,475 @@ Summary: ${accepted} accepted, ${flagged} flagged, ${rejected} rejected`);
   }
 }
 
-// src/api/server.ts
-var pendingLeaderboardAuth = /* @__PURE__ */ new Map();
-function recalcCosts(db) {
-  const BATCH_SIZE2 = 1e3;
-  let updated = 0;
-  let lastId = "";
-  const exchangeRate = resolveExchangeRate(loadConfig() ?? {});
-  while (true) {
-    const records = db.prepare(
-      "SELECT id, tool, model, provider, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens, cost, cost_source FROM records WHERE id > ? ORDER BY id LIMIT ?"
-    ).all(lastId, BATCH_SIZE2);
-    if (records.length === 0) break;
-    const updateStmt = db.prepare("UPDATE records SET model = ?, provider = ?, cost = ?, cost_source = ?, updated_at = ? WHERE id = ?");
-    const tx = db.transaction((batch) => {
-      for (const r of batch) {
-        if (r.cost_source === "log") continue;
-        const rawModel = r.tool === "qoder" ? normalizeQoderModel(r.model) : r.model;
-        const model = rawModel === "unknown" ? r.tool === "qoder" ? "qoder-auto" : r.model : rawModel;
-        const provider = model !== r.model ? inferProvider(model) : r.provider;
-        const hasPrice = resolvePrice(model) != null;
-        const cost = hasPrice ? calculateCost(model, {
-          inputTokens: r.input_tokens,
-          outputTokens: r.output_tokens,
-          cacheReadTokens: r.cache_read_tokens,
-          cacheWriteTokens: r.cache_write_tokens,
-          thinkingTokens: r.thinking_tokens
-        }, exchangeRate) : 0;
-        const costSource = hasPrice ? "pricing" : "unknown";
-        if (model === r.model && provider === r.provider && cost === r.cost && costSource === r.cost_source) continue;
-        updateStmt.run(model, provider, cost, costSource, Date.now(), r.id);
-        updated++;
-      }
-    });
-    tx(records);
-    lastId = records[records.length - 1].id;
-  }
-  return updated;
+// src/commands/parse-kelivo.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { basename as basename2 } from "path";
+import * as yauzl from "yauzl";
+function toTokenCount(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
 }
-function getDateRangeFilter(range, from, to, prefix = "", weekStart = 1) {
-  const ts3 = prefix ? `${prefix}.ts` : "ts";
-  if (from && to) {
-    const startMs = new Date(from).getTime();
-    const endMs = (/* @__PURE__ */ new Date(to + "T23:59:59.999Z")).getTime();
-    return { where: `AND ${ts3} >= @start AND ${ts3} < @end`, params: { start: startMs, end: endMs } };
-  }
-  const now = /* @__PURE__ */ new Date();
-  const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
-  if (range === "week") {
-    const dayOfWeek = today.getDay();
-    const diff = (dayOfWeek - weekStart + 7) % 7;
-    const startOfWeek = new Date(today);
-    startOfWeek.setDate(today.getDate() - diff);
-    return { where: `AND ${ts3} >= @start`, params: { start: startOfWeek.getTime() } };
-  }
-  if (range === "month") {
-    const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
-    return { where: `AND ${ts3} >= @start`, params: { start: startOfMonth.getTime() } };
-  }
-  if (range === "last30") {
-    const start = new Date(today);
-    start.setDate(start.getDate() - 30);
-    return { where: `AND ${ts3} >= @start`, params: { start: start.getTime() } };
-  }
-  if (range === "all") {
-    return { where: "", params: {} };
+function parseTimestamp(value, fallback) {
+  if (typeof value === "number" && Number.isFinite(value)) return value < 1e12 ? value * 1e3 : value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = new Date(value).getTime();
+    if (Number.isFinite(parsed)) return parsed;
   }
-  return { where: `AND ${ts3} >= @start`, params: { start: today.getTime() } };
-}
-function json(res, data, status = 200) {
-  res.writeHead(status, { "Content-Type": "application/json" });
-  res.end(JSON.stringify(data));
-}
-async function readJsonBody(req) {
-  let body = "";
-  for await (const chunk of req) body += chunk;
-  if (!body.trim()) return {};
-  return JSON.parse(body);
+  return fallback;
 }
-function getDeviceName() {
-  return loadConfig()?.device || hostname() || `${platform3()}-${process.arch}`;
+async function readZipEntryText(filePath, entryName) {
+  return new Promise((resolve2, reject) => {
+    yauzl.open(filePath, { lazyEntries: true }, (openError, zipfile) => {
+      if (openError) {
+        reject(openError);
+        return;
+      }
+      if (!zipfile) {
+        reject(new Error("Unable to open zip file"));
+        return;
+      }
+      let settled = false;
+      zipfile.readEntry();
+      zipfile.on("entry", (entry) => {
+        if (basename2(entry.fileName) !== entryName) {
+          zipfile.readEntry();
+          return;
+        }
+        zipfile.openReadStream(entry, (streamError, stream) => {
+          if (streamError) {
+            settled = true;
+            zipfile.close();
+            reject(streamError);
+            return;
+          }
+          if (!stream) {
+            settled = true;
+            zipfile.close();
+            reject(new Error(`Missing ${entryName} stream`));
+            return;
+          }
+          const chunks = [];
+          stream.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+          stream.on("error", (e) => {
+            settled = true;
+            zipfile.close();
+            reject(e);
+          });
+          stream.on("end", () => {
+            settled = true;
+            zipfile.close();
+            resolve2(Buffer.concat(chunks).toString("utf-8"));
+          });
+        });
+      });
+      zipfile.on("end", () => {
+        if (!settled) reject(new Error(`${entryName} not found in zip`));
+      });
+      zipfile.on("error", (e) => {
+        if (!settled) reject(e);
+      });
+    });
+  });
 }
-function getLeaderboardFallback(periodType) {
-  return {
-    entries: [],
-    next_cursor: null,
-    current_user: null,
-    period_type: periodType,
-    period_start: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
-    source_status: "unavailable"
-  };
+async function readKelivoExport(filePath) {
+  const text = filePath.endsWith(".zip") ? await readZipEntryText(filePath, "chats.json") : readFileSync6(filePath, "utf-8");
+  return JSON.parse(text);
 }
-async function proxyLeaderboard(res, url) {
-  const periodType = url.searchParams.get("period_type") || "daily";
-  const upstreamBase = getSiteUrl();
-  const upstream = new URL("/api/leaderboard", upstreamBase);
-  upstream.searchParams.set("period_type", periodType);
+async function runParseKelivo(options) {
+  const { filePath, device, deviceInstanceId, platform: platform5, now, exchangeRate } = options;
+  const records = [];
+  const errors = [];
+  let parsed;
+  try {
+    parsed = await readKelivoExport(filePath);
+  } catch (e) {
+    return { records, errors: [`${filePath}: ${e instanceof Error ? e.message : e}`] };
+  }
+  const messages = Array.isArray(parsed?.messages) ? parsed.messages : [];
+  for (const [index, message] of messages.entries()) {
+    if (message?.role !== "assistant") continue;
+    const promptTokens = toTokenCount(message.promptTokens);
+    const completionTokens = toTokenCount(message.completionTokens);
+    const cachedTokens = toTokenCount(message.cachedTokens);
+    const totalTokens = toTokenCount(message.totalTokens);
+    const inputTokens = promptTokens > 0 ? Math.max(0, promptTokens - cachedTokens) : Math.max(0, totalTokens - completionTokens - cachedTokens);
+    const outputTokens = completionTokens;
+    const cacheReadTokens = cachedTokens;
+    const cacheWriteTokens = 0;
+    const thinkingTokens = 0;
+    if (inputTokens + outputTokens + cacheReadTokens === 0) continue;
+    const model = typeof message.modelId === "string" && message.modelId.trim() ? message.modelId.trim() : "unknown";
+    const provider = typeof message.providerId === "string" && message.providerId.trim() ? message.providerId.trim() : inferProvider(model);
+    const ts3 = parseTimestamp(message.timestamp, now);
+    const sessionId = typeof message.conversationId === "string" && message.conversationId.trim() ? message.conversationId.trim() : "unknown";
+    const messageId = typeof message.id === "string" && message.id.trim() ? message.id.trim() : `${sessionId}:${ts3}:${index}`;
+    const sourceKey = `kelivo:${sessionId}:${messageId}`;
+    const tokenArgs = { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, thinkingTokens };
+    const cost = model !== "unknown" ? calculateCost(model, tokenArgs, exchangeRate) : 0;
+    records.push({
+      id: generateRecordId(deviceInstanceId, sourceKey, ts3),
+      ts: ts3,
+      ingestedAt: now,
+      updatedAt: now,
+      lineOffset: index,
+      tool: "kelivo",
+      model,
+      provider,
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      thinkingTokens,
+      cost,
+      costSource: cost > 0 ? "pricing" : "unknown",
+      sessionId,
+      sourceFile: filePath,
+      device,
+      deviceInstanceId,
+      platform: platform5
+    });
+  }
+  return { records, errors };
+}
+
+// src/db/records.ts
+function insertRecord(db, record) {
+  db.prepare(`
+    INSERT OR REPLACE INTO records (
+      id, ts, ingested_at, synced_at, updated_at, line_offset,
+      tool, model, provider, input_tokens, output_tokens,
+      cache_read_tokens, cache_write_tokens, thinking_tokens,
+      cost, cost_source, session_id, source_file, cwd, device, device_instance_id, platform
+    ) VALUES (
+      @id, @ts, @ingestedAt, @syncedAt, @updatedAt, @lineOffset,
+      @tool, @model, @provider, @inputTokens, @outputTokens,
+      @cacheReadTokens, @cacheWriteTokens, @thinkingTokens,
+      @cost, @costSource, @sessionId, @sourceFile, @cwd, @device, @deviceInstanceId, @platform
+    )
+  `).run({
+    id: record.id,
+    ts: record.ts,
+    ingestedAt: record.ingestedAt,
+    syncedAt: record.syncedAt ?? null,
+    updatedAt: record.updatedAt,
+    lineOffset: record.lineOffset,
+    tool: record.tool,
+    model: record.model,
+    provider: record.provider,
+    inputTokens: record.inputTokens,
+    outputTokens: record.outputTokens,
+    cacheReadTokens: record.cacheReadTokens,
+    cacheWriteTokens: record.cacheWriteTokens,
+    thinkingTokens: record.thinkingTokens,
+    cost: record.cost,
+    costSource: record.costSource,
+    sessionId: record.sessionId,
+    sourceFile: record.sourceFile,
+    cwd: record.cwd ?? "",
+    device: record.device,
+    deviceInstanceId: record.deviceInstanceId,
+    platform: record.platform ?? ""
+  });
+}
+function getUnsyncedRecords(db, target) {
+  const rows = target ? db.prepare(`
+        SELECT r.* FROM records r
+        LEFT JOIN sync_record_state s
+          ON s.record_id = r.id AND s.target = ?
+        WHERE r.source_file NOT LIKE 'synced/%'
+          AND (s.synced_at IS NULL OR r.updated_at > s.synced_at)
+      `).all(target) : db.prepare(
+    "SELECT * FROM records WHERE synced_at IS NULL OR updated_at > synced_at"
+  ).all();
+  return rows.map(mapRowToRecord);
+}
+function markRecordsSynced(db, ids, syncedAt, target) {
+  if (ids.length === 0) return;
+  if (target) {
+    const insertStmt = db.prepare(`
+      INSERT INTO sync_record_state (record_id, target, synced_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(record_id, target) DO UPDATE SET synced_at = excluded.synced_at
+    `);
+    const legacyStmt = db.prepare("UPDATE records SET synced_at = ? WHERE id = ?");
+    const tx2 = db.transaction((recordIds) => {
+      for (const id of recordIds) {
+        insertStmt.run(id, target, syncedAt);
+        legacyStmt.run(syncedAt, id);
+      }
+    });
+    tx2(ids);
+    return;
+  }
+  const updateStmt = db.prepare("UPDATE records SET synced_at = ? WHERE id = ?");
+  const tx = db.transaction((recordIds) => {
+    for (const id of recordIds) updateStmt.run(syncedAt, id);
+  });
+  tx(ids);
+}
+function mapRowToRecord(row) {
+  return {
+    id: row.id,
+    ts: row.ts,
+    ingestedAt: row.ingested_at,
+    syncedAt: row.synced_at != null ? row.synced_at : void 0,
+    updatedAt: row.updated_at,
+    lineOffset: row.line_offset,
+    tool: row.tool,
+    model: row.model,
+    provider: row.provider,
+    inputTokens: row.input_tokens,
+    outputTokens: row.output_tokens,
+    cacheReadTokens: row.cache_read_tokens,
+    cacheWriteTokens: row.cache_write_tokens,
+    thinkingTokens: row.thinking_tokens,
+    cost: row.cost,
+    costSource: row.cost_source,
+    sessionId: row.session_id,
+    sourceFile: row.source_file,
+    cwd: row.cwd || void 0,
+    device: row.device,
+    deviceInstanceId: row.device_instance_id,
+    platform: row.platform || void 0
+  };
+}
+
+// src/db/write-queue.ts
+var AsyncTaskQueue = class {
+  tail = Promise.resolve();
+  running = false;
+  pending = 0;
+  run(task) {
+    this.pending++;
+    const runTask = async () => {
+      this.pending--;
+      this.running = true;
+      try {
+        return await task();
+      } finally {
+        this.running = false;
+      }
+    };
+    const result = this.tail.then(runTask, runTask);
+    this.tail = result.catch(() => void 0);
+    return result;
+  }
+  getStatus() {
+    return { running: this.running, pending: this.pending };
+  }
+};
+
+// src/api/server.ts
+var pendingLeaderboardAuth = /* @__PURE__ */ new Map();
+function getManualImportMetadata(db) {
+  const rows = db.prepare(`
+    SELECT tool, MAX(ingested_at) AS lastImportedAt
+    FROM records
+    WHERE tool IN ('kelivo')
+    GROUP BY tool
+  `).all();
+  const metadata = {};
+  for (const row of rows) {
+    if (typeof row.lastImportedAt === "number") {
+      metadata[row.tool] = { lastImportedAt: row.lastImportedAt };
+    }
+  }
+  return metadata;
+}
+function attachManualImportMetadata(tools, db) {
+  const metadata = getManualImportMetadata(db);
+  return tools.map((tool) => {
+    const toolMetadata = metadata[tool.tool];
+    return toolMetadata ? { ...tool, ...toolMetadata } : tool;
+  });
+}
+function countExistingRecordIds(db, ids) {
+  const uniqueIds = [...new Set(ids)];
+  if (uniqueIds.length === 0) return 0;
+  const stmt = db.prepare("SELECT 1 FROM records WHERE id = ? LIMIT 1");
+  let count = 0;
+  for (const id of uniqueIds) {
+    if (stmt.get(id)) count++;
+  }
+  return count;
+}
+function emptyPricingRecalcStatus() {
+  return {
+    state: "idle",
+    needsRecalc: false,
+    needsRecalcSince: null,
+    total: 0,
+    processed: 0,
+    updated: 0,
+    skipped: 0,
+    queueRunning: false,
+    queuePending: 0,
+    startedAt: null,
+    finishedAt: null,
+    error: null
+  };
+}
+async function recalcCosts(db, onProgress) {
+  const BATCH_SIZE2 = 1e3;
+  let updated = 0;
+  let processed = 0;
+  let skipped = 0;
+  let lastId = "";
+  const exchangeRate = resolveExchangeRate(loadConfig() ?? {});
+  const priceCache = /* @__PURE__ */ new Map();
+  const resolveCachedPrice = (model) => {
+    if (priceCache.has(model)) return priceCache.get(model) ?? void 0;
+    const price = resolvePriceFromRegistry(db, model) ?? null;
+    priceCache.set(model, price);
+    return price ?? void 0;
+  };
+  const totalRow = db.prepare("SELECT COUNT(*) AS total FROM records").get();
+  const total = totalRow.total;
+  onProgress?.({ total, processed, updated, skipped });
+  while (true) {
+    const records = db.prepare(
+      "SELECT id, tool, model, provider, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens, cost, cost_source FROM records WHERE id > ? ORDER BY id LIMIT ?"
+    ).all(lastId, BATCH_SIZE2);
+    if (records.length === 0) break;
+    const updateStmt = db.prepare("UPDATE records SET model = ?, provider = ?, cost = ?, cost_source = ?, updated_at = ? WHERE id = ?");
+    const tx = db.transaction((batch) => {
+      for (const r of batch) {
+        processed++;
+        if (r.cost_source === "log") {
+          skipped++;
+          continue;
+        }
+        const rawModel = r.tool === "qoder" ? normalizeQoderModel(r.model) : r.model;
+        const model = rawModel === "unknown" ? r.tool === "qoder" ? "qoder-auto" : r.model : rawModel;
+        const provider = model !== r.model ? inferProvider(model) : r.provider;
+        const price = resolveCachedPrice(model);
+        const cost = price ? calculateCostForPrice(price, {
+          inputTokens: r.input_tokens,
+          outputTokens: r.output_tokens,
+          cacheReadTokens: r.cache_read_tokens,
+          cacheWriteTokens: r.cache_write_tokens,
+          thinkingTokens: r.thinking_tokens
+        }, exchangeRate) : 0;
+        const costSource = price ? "pricing" : "unknown";
+        if (model === r.model && provider === r.provider && cost === r.cost && costSource === r.cost_source) continue;
+        updateStmt.run(model, provider, cost, costSource, Date.now(), r.id);
+        updated++;
+      }
+    });
+    tx(records);
+    lastId = records[records.length - 1].id;
+    onProgress?.({ total, processed, updated, skipped });
+    await new Promise((resolve2) => setImmediate(resolve2));
+  }
+  return updated;
+}
+function getDateRangeFilter(range, from, to, prefix = "", weekStart = 1) {
+  const ts3 = prefix ? `${prefix}.ts` : "ts";
+  if (from && to) {
+    const startMs = new Date(from).getTime();
+    const endMs = (/* @__PURE__ */ new Date(to + "T23:59:59.999Z")).getTime();
+    return { where: `AND ${ts3} >= @start AND ${ts3} < @end`, params: { start: startMs, end: endMs } };
+  }
+  const now = /* @__PURE__ */ new Date();
+  const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  if (range === "week") {
+    const dayOfWeek = today.getDay();
+    const diff = (dayOfWeek - weekStart + 7) % 7;
+    const startOfWeek = new Date(today);
+    startOfWeek.setDate(today.getDate() - diff);
+    return { where: `AND ${ts3} >= @start`, params: { start: startOfWeek.getTime() } };
+  }
+  if (range === "month") {
+    const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+    return { where: `AND ${ts3} >= @start`, params: { start: startOfMonth.getTime() } };
+  }
+  if (range === "last30") {
+    const start = new Date(today);
+    start.setDate(start.getDate() - 30);
+    return { where: `AND ${ts3} >= @start`, params: { start: start.getTime() } };
+  }
+  if (range === "all") {
+    return { where: "", params: {} };
+  }
+  return { where: `AND ${ts3} >= @start`, params: { start: today.getTime() } };
+}
+function json(res, data, status = 200) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+function isDatabaseLockedError(error) {
+  return error instanceof Error && /database is locked|SQLITE_BUSY/i.test(error.message);
+}
+function databaseBusy(res) {
+  json(res, {
+    error: {
+      code: "DATABASE_BUSY",
+      message: "Database is busy. Wait for the current refresh, sync, or import to finish and retry."
+    }
+  }, 503);
+}
+async function readJsonBody(req) {
+  let body = "";
+  for await (const chunk of req) body += chunk;
+  if (!body.trim()) return {};
+  return JSON.parse(body);
+}
+async function readBodyBuffer(req) {
+  const chunks = [];
+  for await (const chunk of req) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  return Buffer.concat(chunks);
+}
+function multipartBoundary(contentType) {
+  const value = Array.isArray(contentType) ? contentType[0] : contentType;
+  if (!value) return null;
+  const match = value.match(/(?:^|;)\s*boundary=("([^"]+)"|[^;]+)/i);
+  if (!match) return null;
+  return (match[2] ?? match[1]).replace(/^"|"$/g, "");
+}
+async function readMultipartFile(req) {
+  const boundary = multipartBoundary(req.headers["content-type"]);
+  if (!boundary) return null;
+  const body = await readBodyBuffer(req);
+  const marker = Buffer.from(`--${boundary}`);
+  let position = body.indexOf(marker);
+  while (position !== -1) {
+    position += marker.length;
+    if (body.subarray(position, position + 2).toString() === "--") return null;
+    if (body.subarray(position, position + 2).toString() === "\r\n") position += 2;
+    const headerEnd = body.indexOf(Buffer.from("\r\n\r\n"), position);
+    if (headerEnd === -1) return null;
+    const headers = body.subarray(position, headerEnd).toString("utf-8");
+    const filenameMatch = headers.match(/Content-Disposition:[^\r\n]*\bname="file"[^\r\n]*\bfilename="([^"]+)"/i);
+    const dataStart = headerEnd + 4;
+    const nextBoundary = body.indexOf(Buffer.from(`\r
+--${boundary}`), dataStart);
+    if (nextBoundary === -1) return null;
+    if (filenameMatch) return { filename: path2.basename(filenameMatch[1]), data: body.subarray(dataStart, nextBoundary) };
+    position = body.indexOf(marker, nextBoundary);
+  }
+  return null;
+}
+function isKelivoBackupFilename(filename) {
+  return filename === "chats.json" || filename.toLowerCase().endsWith(".zip");
+}
+function getDeviceName() {
+  return loadConfig()?.device || hostname() || `${platform3()}-${process.arch}`;
+}
+function getLeaderboardFallback(periodType) {
+  return {
+    entries: [],
+    next_cursor: null,
+    current_user: null,
+    period_type: periodType,
+    period_start: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+    source_status: "unavailable"
+  };
+}
+async function proxyLeaderboard(res, url) {
+  const periodType = url.searchParams.get("period_type") || "daily";
+  const upstreamBase = getSiteUrl();
+  const upstream = new URL("/api/leaderboard", upstreamBase);
+  upstream.searchParams.set("period_type", periodType);
   const periodStart = url.searchParams.get("period_start");
   if (periodStart) upstream.searchParams.set("period_start", periodStart);
   const cursor = url.searchParams.get("cursor");
@@ -3764,6 +4652,23 @@ async function proxyLeaderboard(res, url) {
     json(res, getLeaderboardFallback(periodType));
   }
 }
+async function proxyCloudSyncStatus(res) {
+  const upstream = new URL("/api/cli/sync/status", getSiteUrl());
+  try {
+    const response = await fetch(upstream, {
+      headers: { Accept: "application/json" }
+    });
+    const contentType = response.headers.get("content-type") || "";
+    if (!response.ok || !contentType.includes("application/json")) {
+      json(res, { enabled: false });
+      return;
+    }
+    const data = await response.json().catch(() => null);
+    json(res, data && typeof data.enabled === "boolean" ? data : { enabled: false });
+  } catch {
+    json(res, { enabled: false });
+  }
+}
 function getToolFilter(tool, prefix = "") {
   if (!tool) return { where: "", params: {} };
   const col = prefix ? `${prefix}.tool` : "tool";
@@ -3817,6 +4722,90 @@ function createApiServer(db, options) {
   const cfg = loadConfig();
   let weekStart = cfg?.weekStart ?? 1;
   const dashboardPassword = getDashboardPassword();
+  const localWriteQueue = new AsyncTaskQueue();
+  const runDbWrite = options?.runDbWrite ?? ((task) => localWriteQueue.run(task));
+  const getDbWriteQueueStatus = options?.getDbWriteQueueStatus ?? (() => localWriteQueue.getStatus());
+  let pricingRecalcStatus = emptyPricingRecalcStatus();
+  let pricingNeedsRecalcSince = null;
+  let pricingRecalcGeneration = 0;
+  const currentPricingRecalcStatus = () => {
+    const status = {
+      ...pricingRecalcStatus,
+      needsRecalc: pricingNeedsRecalcSince != null,
+      needsRecalcSince: pricingNeedsRecalcSince
+    };
+    if (status.state !== "queued") return status;
+    const queueStatus = getDbWriteQueueStatus();
+    return {
+      ...status,
+      queueRunning: queueStatus.running,
+      queuePending: queueStatus.pending
+    };
+  };
+  const markPricingNeedsRecalc = () => {
+    pricingRecalcGeneration += 1;
+    pricingNeedsRecalcSince = Date.now();
+    return pricingNeedsRecalcSince;
+  };
+  const startPricingRecalc = () => {
+    if (pricingRecalcStatus.state === "queued" || pricingRecalcStatus.state === "running") {
+      return { accepted: false, status: currentPricingRecalcStatus() };
+    }
+    const startedAt = Date.now();
+    const startedGeneration = pricingRecalcGeneration;
+    pricingRecalcStatus = {
+      ...emptyPricingRecalcStatus(),
+      state: "running",
+      startedAt
+    };
+    const runRecalc = async () => {
+      pricingRecalcStatus = {
+        ...pricingRecalcStatus,
+        state: "running",
+        queueRunning: false,
+        queuePending: 0,
+        startedAt: pricingRecalcStatus.startedAt ?? Date.now()
+      };
+      try {
+        await recalcCosts(db, (progress) => {
+          pricingRecalcStatus = {
+            ...pricingRecalcStatus,
+            ...progress,
+            state: "running"
+          };
+        });
+        if (pricingNeedsRecalcSince != null && pricingRecalcGeneration === startedGeneration) {
+          pricingNeedsRecalcSince = null;
+        }
+        pricingRecalcStatus = {
+          ...pricingRecalcStatus,
+          state: "done",
+          needsRecalc: pricingNeedsRecalcSince != null,
+          needsRecalcSince: pricingNeedsRecalcSince,
+          finishedAt: Date.now(),
+          error: null
+        };
+      } catch (error) {
+        pricingRecalcStatus = {
+          ...pricingRecalcStatus,
+          state: "error",
+          finishedAt: Date.now(),
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    };
+    setImmediate(() => {
+      void runRecalc().catch((error) => {
+        pricingRecalcStatus = {
+          ...pricingRecalcStatus,
+          state: "error",
+          finishedAt: Date.now(),
+          error: error instanceof Error ? error.message : String(error)
+        };
+      });
+    });
+    return { accepted: true, status: currentPricingRecalcStatus() };
+  };
   const server = http.createServer(async (req, res) => {
     const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
     res.setHeader("Access-Control-Allow-Origin", "*");
@@ -3855,6 +4844,10 @@ function createApiServer(db, options) {
       json(res, { ok: true });
       return;
     }
+    if (url.pathname === "/api/cli/sync/status" && req.method === "GET") {
+      await proxyCloudSyncStatus(res);
+      return;
+    }
     if (dashboardPassword && shouldProtectApiPath(url.pathname) && !isAuthenticated(dashboardPassword, req.headers.cookie)) {
       json(res, { error: { code: "UNAUTHORIZED", message: "Authentication required" } }, 401);
       return;
@@ -4470,72 +5463,48 @@ function createApiServer(db, options) {
       }
       if (url.pathname === "/api/pricing") {
         if (req.method === "GET") {
-          const table = getPriceTable();
-          const overrides = getUserOverrides();
-          const dbModels = db.prepare("SELECT model, COUNT(*) as usage_count FROM records WHERE model != 'unknown' GROUP BY model ORDER BY usage_count DESC, model ASC").all();
-          const models = dbModels.map((r) => {
-            const model = r.model;
-            const exactPrice = table[model];
-            const resolvedPrice = resolvePrice(model);
-            const isOverride = model in overrides;
-            const isDefault = model in DEFAULT_PRICE_TABLE && !isOverride;
-            let matchedBy = null;
-            if (!exactPrice && resolvedPrice) {
-              for (const prefix of Object.keys(table)) {
-                if (model.startsWith(prefix) || model.toLowerCase().startsWith(prefix)) {
-                  matchedBy = prefix;
-                  break;
-                }
-              }
-              if (!matchedBy) {
-                const stripped = model.replace(/^[^/]+\//, "").toLowerCase();
-                for (const prefix of Object.keys(table)) {
-                  if (stripped.startsWith(prefix)) {
-                    matchedBy = prefix;
-                    break;
-                  }
-                }
-              }
-            }
-            return {
-              model,
-              price: resolvedPrice ?? null,
-              currency: resolvedPrice?.currency ?? "USD",
-              isDefault,
-              isOverride,
-              matchedBy
-            };
-          });
-          json(res, { models, overrides });
+          json(res, { models: listPricingModels(db), registry: getPricingRegistrySummary(db), targets: listPricingAliasTargets(db), aliasBindings: getUserAliasBindings(db), localBindings: listLocalModelBindings(db) });
           return;
         }
         if (req.method === "PUT") {
           let body = "";
           for await (const chunk of req) body += chunk;
+          let data;
           try {
-            const data = JSON.parse(body);
-            if (!data.model || typeof data.input !== "number" || typeof data.output !== "number") {
-              json(res, { error: { code: "INVALID_PARAM", message: "model, input, output required" } }, 400);
-              return;
-            }
-            const entry = {
-              input: data.input,
-              output: data.output,
-              cacheRead: data.cacheRead,
-              cacheWrite: data.cacheWrite
-            };
-            if (data.currency === "CNY") {
-              entry.currency = "CNY";
-            }
-            setPriceOverride(data.model, entry);
-            const cfg2 = loadConfig() ?? {};
-            cfg2.priceOverrides = { ...cfg2.priceOverrides, [data.model]: entry };
-            saveConfig(cfg2);
-            const recalculated = recalcCosts(db);
-            json(res, { ok: true, recalculated });
+            data = JSON.parse(body);
           } catch {
             json(res, { error: { code: "INVALID_JSON", message: "Invalid JSON body" } }, 400);
+            return;
+          }
+          if (!data.model || typeof data.input !== "number" || typeof data.output !== "number") {
+            json(res, { error: { code: "INVALID_PARAM", message: "model, input, output required" } }, 400);
+            return;
+          }
+          const entry = {
+            input: data.input,
+            output: data.output,
+            cacheRead: data.cacheRead,
+            cacheWrite: data.cacheWrite
+          };
+          if (data.currency === "CNY") {
+            entry.currency = "CNY";
           }
+          try {
+            await runDbWrite(() => {
+              setUserPrice(db, data.model, entry);
+              const cfg2 = loadConfig() ?? {};
+              cfg2.priceOverrides = { ...cfg2.priceOverrides, [data.model]: entry };
+              saveConfig(cfg2);
+              loadPricingRuntime(db, cfg2);
+            });
+          } catch (error) {
+            if (isDatabaseLockedError(error)) {
+              databaseBusy(res);
+              return;
+            }
+            throw error;
+          }
+          json(res, { ok: true, needsRecalc: true, needsRecalcSince: markPricingNeedsRecalc() });
           return;
         }
         if (req.method === "DELETE") {
@@ -4544,20 +5513,94 @@ function createApiServer(db, options) {
             json(res, { error: { code: "INVALID_PARAM", message: "model param required" } }, 400);
             return;
           }
-          removePriceOverride(model);
-          const cfg2 = loadConfig() ?? {};
-          if (cfg2.priceOverrides) {
-            delete cfg2.priceOverrides[model];
-            saveConfig(cfg2);
+          try {
+            await runDbWrite(() => {
+              resetUserPriceToSynced(db, model);
+              removePriceOverride(model);
+              const cfg2 = loadConfig() ?? {};
+              if (cfg2.priceOverrides) {
+                delete cfg2.priceOverrides[model];
+                saveConfig(cfg2);
+              }
+              loadPricingRuntime(db, cfg2);
+            });
+            json(res, { ok: true, needsRecalc: true, needsRecalcSince: markPricingNeedsRecalc() });
+          } catch (error) {
+            if (isDatabaseLockedError(error)) {
+              databaseBusy(res);
+              return;
+            }
+            throw error;
           }
-          const recalculated = recalcCosts(db);
-          json(res, { ok: true, recalculated });
           return;
         }
       }
+      if (url.pathname === "/api/pricing/alias" && req.method === "POST") {
+        try {
+          const data = await readJsonBody(req);
+          if (typeof data.alias !== "string" || typeof data.modelKey !== "string") {
+            json(res, { error: { code: "INVALID_PARAM", message: "alias and modelKey required" } }, 400);
+            return;
+          }
+          await runDbWrite(() => {
+            setUserPricingAlias(db, data.alias, data.modelKey);
+            loadPricingRuntime(db, loadConfig());
+          });
+          json(res, { ok: true, needsRecalc: true, needsRecalcSince: markPricingNeedsRecalc() });
+        } catch (error) {
+          if (isDatabaseLockedError(error)) {
+            databaseBusy(res);
+            return;
+          }
+          json(res, { error: { code: "INVALID_PARAM", message: error instanceof Error ? error.message : "Invalid pricing alias" } }, 400);
+        }
+        return;
+      }
+      if (url.pathname === "/api/pricing/alias" && req.method === "DELETE") {
+        const alias = url.searchParams.get("alias");
+        if (!alias) {
+          json(res, { error: { code: "INVALID_PARAM", message: "alias param required" } }, 400);
+          return;
+        }
+        try {
+          await runDbWrite(() => {
+            removeUserPricingAlias(db, alias);
+            loadPricingRuntime(db, loadConfig());
+          });
+          json(res, { ok: true, needsRecalc: true, needsRecalcSince: markPricingNeedsRecalc() });
+        } catch (error) {
+          if (isDatabaseLockedError(error)) {
+            databaseBusy(res);
+            return;
+          }
+          json(res, { error: { code: "INVALID_PARAM", message: error instanceof Error ? error.message : "Invalid pricing alias" } }, 400);
+        }
+        return;
+      }
+      if (url.pathname === "/api/pricing/sync" && req.method === "POST") {
+        try {
+          const summary = await runDbWrite(async () => {
+            const summary2 = await syncPricingFromLitellm(db);
+            loadPricingRuntime(db, loadConfig());
+            return summary2;
+          });
+          json(res, { ok: true, summary, needsRecalc: true, needsRecalcSince: markPricingNeedsRecalc() });
+        } catch (error) {
+          if (isDatabaseLockedError(error)) {
+            databaseBusy(res);
+            return;
+          }
+          json(res, { error: { code: "SYNC_FAILED", message: error instanceof Error ? error.message : "Pricing sync failed" } }, 502);
+        }
+        return;
+      }
+      if (url.pathname === "/api/pricing/recalc" && req.method === "GET") {
+        json(res, currentPricingRecalcStatus());
+        return;
+      }
       if (url.pathname === "/api/pricing/recalc" && req.method === "POST") {
-        const updated = recalcCosts(db);
-        json(res, { updated });
+        const result = startPricingRecalc();
+        json(res, result, result.accepted ? 202 : 200);
         return;
       }
       if (url.pathname === "/api/sync") {
@@ -4579,8 +5622,16 @@ function createApiServer(db, options) {
           json(res, { error: { code: "NOT_AVAILABLE", message: "Refresh not available" } }, 501);
           return;
         }
-        const result = await options.onRefresh();
-        json(res, result);
+        try {
+          const result = await runDbWrite(() => options.onRefresh());
+          json(res, result);
+        } catch (error) {
+          if (isDatabaseLockedError(error)) {
+            databaseBusy(res);
+            return;
+          }
+          throw error;
+        }
         return;
       }
       if (url.pathname === "/api/quotas" && req.method === "GET") {
@@ -4954,141 +6005,86 @@ function createApiServer(db, options) {
         }
       }
       if (url.pathname === "/api/detected-tools" && req.method === "GET") {
-        const tools = discoverTools();
+        const tools = attachManualImportMetadata(discoverTools(), db);
         json(res, { tools });
         return;
       }
-      if (url.pathname === "/api/exchange-rate/refresh" && req.method === "POST") {
-        const rate = await fetchExchangeRate();
-        if (rate == null) {
-          json(res, { error: { code: "FETCH_FAILED", message: "Failed to fetch exchange rate" } }, 502);
-          return;
-        }
-        const cfg2 = loadConfig() ?? {};
-        cfg2.exchangeRateCache = { CNY_USD: rate, fetchedAt: Date.now() };
-        saveConfig(cfg2);
-        json(res, { rate, fetchedAt: cfg2.exchangeRateCache.fetchedAt });
-        return;
-      }
-      json(res, { error: { code: "NOT_FOUND", message: "Endpoint not found" } }, 404);
-    } catch (error) {
-      console.error("API error:", error);
-      json(res, { error: { code: "INTERNAL", message: "Internal server error" } }, 500);
-    }
-  });
-  return server;
-}
-
-// src/commands/parse.ts
-import Database2 from "better-sqlite3";
-import { readFileSync as readFileSync7, statSync as statSync2, existsSync as existsSync8, openSync, readSync, closeSync } from "fs";
-import { join as join7 } from "path";
-import { hostname as hostname2 } from "os";
-
-// src/db/records.ts
-function insertRecord(db, record) {
-  db.prepare(`
-    INSERT OR REPLACE INTO records (
-      id, ts, ingested_at, synced_at, updated_at, line_offset,
-      tool, model, provider, input_tokens, output_tokens,
-      cache_read_tokens, cache_write_tokens, thinking_tokens,
-      cost, cost_source, session_id, source_file, cwd, device, device_instance_id, platform
-    ) VALUES (
-      @id, @ts, @ingestedAt, @syncedAt, @updatedAt, @lineOffset,
-      @tool, @model, @provider, @inputTokens, @outputTokens,
-      @cacheReadTokens, @cacheWriteTokens, @thinkingTokens,
-      @cost, @costSource, @sessionId, @sourceFile, @cwd, @device, @deviceInstanceId, @platform
-    )
-  `).run({
-    id: record.id,
-    ts: record.ts,
-    ingestedAt: record.ingestedAt,
-    syncedAt: record.syncedAt ?? null,
-    updatedAt: record.updatedAt,
-    lineOffset: record.lineOffset,
-    tool: record.tool,
-    model: record.model,
-    provider: record.provider,
-    inputTokens: record.inputTokens,
-    outputTokens: record.outputTokens,
-    cacheReadTokens: record.cacheReadTokens,
-    cacheWriteTokens: record.cacheWriteTokens,
-    thinkingTokens: record.thinkingTokens,
-    cost: record.cost,
-    costSource: record.costSource,
-    sessionId: record.sessionId,
-    sourceFile: record.sourceFile,
-    cwd: record.cwd ?? "",
-    device: record.device,
-    deviceInstanceId: record.deviceInstanceId,
-    platform: record.platform ?? ""
-  });
-}
-function getUnsyncedRecords(db, target) {
-  const rows = target ? db.prepare(`
-        SELECT r.* FROM records r
-        LEFT JOIN sync_record_state s
-          ON s.record_id = r.id AND s.target = ?
-        WHERE r.source_file NOT LIKE 'synced/%'
-          AND (s.synced_at IS NULL OR r.updated_at > s.synced_at)
-      `).all(target) : db.prepare(
-    "SELECT * FROM records WHERE synced_at IS NULL OR updated_at > synced_at"
-  ).all();
-  return rows.map(mapRowToRecord);
-}
-function markRecordsSynced(db, ids, syncedAt, target) {
-  if (ids.length === 0) return;
-  if (target) {
-    const insertStmt = db.prepare(`
-      INSERT INTO sync_record_state (record_id, target, synced_at)
-      VALUES (?, ?, ?)
-      ON CONFLICT(record_id, target) DO UPDATE SET synced_at = excluded.synced_at
-    `);
-    const legacyStmt = db.prepare("UPDATE records SET synced_at = ? WHERE id = ?");
-    const tx2 = db.transaction((recordIds) => {
-      for (const id of recordIds) {
-        insertStmt.run(id, target, syncedAt);
-        legacyStmt.run(syncedAt, id);
+      if (url.pathname === "/api/import/kelivo" && req.method === "POST") {
+        let tempDir = null;
+        try {
+          const upload = await readMultipartFile(req);
+          if (!upload) {
+            json(res, { error: { code: "INVALID_UPLOAD", message: "Missing uploaded file" } }, 400);
+            return;
+          }
+          if (!isKelivoBackupFilename(upload.filename)) {
+            json(res, { error: { code: "INVALID_FILE", message: "Upload a Kelivo .zip backup or chats.json" } }, 400);
+            return;
+          }
+          tempDir = mkdtempSync(path2.join(tmpdir(), "aiusage-kelivo-"));
+          const tempPath = path2.join(tempDir, upload.filename);
+          writeFileSync4(tempPath, upload.data);
+          const cfg2 = loadConfig();
+          const now = Date.now();
+          const result = await runParseKelivo({
+            filePath: tempPath,
+            device: getDeviceName(),
+            deviceInstanceId: options?.currentDeviceInstanceId ?? "unknown",
+            platform: cfg2?.platform ?? platform3(),
+            now,
+            exchangeRate: resolveExchangeRate(cfg2 ?? {})
+          });
+          if (result.errors.length > 0 && result.records.length === 0) {
+            json(res, { error: { code: "IMPORT_FAILED", message: result.errors[0] }, errors: result.errors }, 400);
+            return;
+          }
+          const existingCount = await runDbWrite(() => {
+            const existingCount2 = countExistingRecordIds(db, result.records.map((record) => record.id));
+            for (const record of result.records) insertRecord(db, record);
+            return existingCount2;
+          });
+          const imported = result.records.length;
+          const added = Math.max(0, new Set(result.records.map((record) => record.id)).size - existingCount);
+          json(res, {
+            imported,
+            added,
+            lastImportedAt: imported > 0 ? now : void 0,
+            errors: result.errors
+          });
+        } finally {
+          if (tempDir) rmSync(tempDir, { recursive: true, force: true });
+        }
+        return;
       }
-    });
-    tx2(ids);
-    return;
-  }
-  const updateStmt = db.prepare("UPDATE records SET synced_at = ? WHERE id = ?");
-  const tx = db.transaction((recordIds) => {
-    for (const id of recordIds) updateStmt.run(syncedAt, id);
+      if (url.pathname === "/api/exchange-rate/refresh" && req.method === "POST") {
+        const rate = await fetchExchangeRate();
+        if (rate == null) {
+          json(res, { error: { code: "FETCH_FAILED", message: "Failed to fetch exchange rate" } }, 502);
+          return;
+        }
+        const cfg2 = loadConfig() ?? {};
+        cfg2.exchangeRateCache = { CNY_USD: rate, fetchedAt: Date.now() };
+        saveConfig(cfg2);
+        json(res, { rate, fetchedAt: cfg2.exchangeRateCache.fetchedAt });
+        return;
+      }
+      json(res, { error: { code: "NOT_FOUND", message: "Endpoint not found" } }, 404);
+    } catch (error) {
+      console.error("API error:", error);
+      json(res, { error: { code: "INTERNAL", message: "Internal server error" } }, 500);
+    }
   });
-  tx(ids);
-}
-function mapRowToRecord(row) {
-  return {
-    id: row.id,
-    ts: row.ts,
-    ingestedAt: row.ingested_at,
-    syncedAt: row.synced_at != null ? row.synced_at : void 0,
-    updatedAt: row.updated_at,
-    lineOffset: row.line_offset,
-    tool: row.tool,
-    model: row.model,
-    provider: row.provider,
-    inputTokens: row.input_tokens,
-    outputTokens: row.output_tokens,
-    cacheReadTokens: row.cache_read_tokens,
-    cacheWriteTokens: row.cache_write_tokens,
-    thinkingTokens: row.thinking_tokens,
-    cost: row.cost,
-    costSource: row.cost_source,
-    sessionId: row.session_id,
-    sourceFile: row.source_file,
-    cwd: row.cwd || void 0,
-    device: row.device,
-    deviceInstanceId: row.device_instance_id,
-    platform: row.platform || void 0
-  };
+  return server;
 }
 
+// src/commands/parse.ts
+import Database2 from "better-sqlite3";
+import { readFileSync as readFileSync8, statSync as statSync2, existsSync as existsSync8, openSync, readSync, closeSync } from "fs";
+import { join as join7 } from "path";
+import { hostname as hostname2 } from "os";
+
 // src/watermark.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync7 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync7 } from "fs";
 function defaultFileData() {
   return {
     "claude-code": {},
@@ -5099,6 +6095,7 @@ function defaultFileData() {
     "qoder": {},
     "cursor": {},
     "kilocode": {},
+    "kelivo": {},
     "copilot": {},
     "gemini": {},
     "kimi": {},
@@ -5118,8 +6115,8 @@ function defaultFileData() {
 var WatermarkManager = class {
   data;
   path;
-  constructor(path2) {
-    this.path = path2;
+  constructor(path3) {
+    this.path = path3;
     this.data = this.load();
   }
   load() {
@@ -5127,7 +6124,7 @@ var WatermarkManager = class {
       return { files: defaultFileData() };
     }
     try {
-      const content = readFileSync6(this.path, "utf-8");
+      const content = readFileSync7(this.path, "utf-8");
       const parsed = JSON.parse(content);
       if (parsed && typeof parsed === "object" && !("files" in parsed)) {
         return { files: { ...defaultFileData(), ...parsed } };
@@ -5138,7 +6135,7 @@ var WatermarkManager = class {
     }
   }
   save() {
-    writeFileSync4(this.path, JSON.stringify(this.data, null, 2), "utf-8");
+    writeFileSync5(this.path, JSON.stringify(this.data, null, 2), "utf-8");
   }
   getEntry(tool, filePath) {
     return this.data.files[tool]?.[filePath] ?? null;
@@ -6011,6 +7008,11 @@ function extractSessionId2(filePath, tool) {
     const parts = filePath.split("/");
     return (parts.pop() ?? "").replace(".jsonl", "");
   }
+  if (tool === "pi") {
+    const filename = filePath.split("/").pop() ?? "";
+    const match = filename.match(/_([^_]+)\.jsonl$/);
+    return match ? match[1] : filename.replace(".jsonl", "");
+  }
   return "unknown";
 }
 function toNumber2(value) {
@@ -6023,12 +7025,12 @@ function parseUiMessagesFile(options) {
   const errors = [];
   let messages;
   try {
-    const parsed = JSON.parse(readFileSync7(filePath, "utf-8"));
+    const parsed = JSON.parse(readFileSync8(filePath, "utf-8"));
     messages = Array.isArray(parsed) ? parsed : [];
   } catch (e) {
     return { records, errors: [`${filePath}: ${e instanceof Error ? e.message : e}`] };
   }
-  const taskId = filePath.split("/").slice(-2, -1)[0] || "unknown";
+  const taskId = filePath.replace(/\\/g, "/").split("/").slice(-2, -1)[0] || "unknown";
   for (const [index, message] of messages.entries()) {
     if (message?.say !== "api_req_started" || typeof message.text !== "string") continue;
     let payload;
@@ -6080,7 +7082,7 @@ function normalizeKiroModel(value) {
   if (typeof value !== "string" || !value.trim()) return "kiro-agent";
   return value.trim().toLowerCase().replace(/_/g, "-").replace(/^(anthropic\.|openai\.|aws\.)/, "").replace(/:\d+$/, "").replace(/-\d{8}-v\d+(?:-\d+)?$/i, "");
 }
-function parseTimestamp(value, fallback) {
+function parseTimestamp2(value, fallback) {
   if (typeof value === "number" && Number.isFinite(value)) return value < 1e12 ? value * 1e3 : value;
   if (typeof value === "string" && value.trim()) {
     const parsed = new Date(value).getTime();
@@ -6101,7 +7103,7 @@ function parseKiroSessionFile(options) {
   const errors = [];
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync7(filePath, "utf-8"));
+    parsed = JSON.parse(readFileSync8(filePath, "utf-8"));
   } catch (e) {
     return { records, errors: [`${filePath}: ${e instanceof Error ? e.message : e}`] };
   }
@@ -6114,7 +7116,7 @@ function parseKiroSessionFile(options) {
     const outputTokens = toNumber2(turn?.output_token_count);
     if (inputTokens + outputTokens === 0) continue;
     const model = normalizeKiroModel(turn?.model_id ?? sessionModel);
-    const recordTs = parseTimestamp(
+    const recordTs = parseTimestamp2(
       turn?.request_start_timestamp_ms ?? turn?.start_timestamp ?? turn?.end_timestamp,
       now
     );
@@ -6225,7 +7227,30 @@ async function runParse(db, filterTool, options) {
           onProgress({ phase: "Parsing logs", tool, current: fileIndex, total: totalFiles, records: parsedCount, toolCalls: toolCallCount });
           continue;
         }
-        const content = readFileSync7(filePath, "utf-8");
+        if (tool === "kelivo" && (filePath.endsWith("chats.json") || filePath.endsWith(".zip"))) {
+          const result = await runParseKelivo({
+            filePath,
+            device,
+            deviceInstanceId,
+            platform: devicePlatform,
+            now: Date.now(),
+            exchangeRate
+          });
+          for (const record of result.records) {
+            insertRecord(db, record);
+            parsedCount++;
+          }
+          errors.push(...result.errors);
+          wm.setEntry(tool, filePath, {
+            offset: stat2.size,
+            size: stat2.size,
+            mtime: stat2.mtimeMs
+          });
+          wm.save();
+          onProgress({ phase: "Parsing logs", tool, current: fileIndex, total: totalFiles, records: parsedCount, toolCalls: toolCallCount });
+          continue;
+        }
+        const content = readFileSync8(filePath, "utf-8");
         const lines = content.split("\n");
         let byteOffset = 0;
         let fileCwd;
@@ -6680,7 +7705,7 @@ function backfillCodexModels(db) {
   );
   for (const [sourceFile, fileRows] of byFile) {
     try {
-      const content = readFileSync7(sourceFile, "utf-8");
+      const content = readFileSync8(sourceFile, "utf-8");
       const lines = content.split("\n");
       const offsetToModel = /* @__PURE__ */ new Map();
       let currentModel = "";
@@ -6728,7 +7753,7 @@ function backfillMissingToolCalls(db, exchangeRate) {
   }
   for (const [sourceFile, fileRows] of rowsByFile) {
     try {
-      const content = readFileSync7(sourceFile, "utf-8");
+      const content = readFileSync8(sourceFile, "utf-8");
       const lines = content.split("\n");
       const aggregator = new Aggregator();
       const recordIdByOffset = /* @__PURE__ */ new Map();
@@ -6794,7 +7819,7 @@ import { join as join9 } from "path";
 
 // src/db/synced-records.ts
 function insertSyncedRecord(db, record) {
-  db.prepare(`
+  const result = db.prepare(`
     INSERT INTO synced_records (
       id, ts, tool, model, provider, input_tokens, output_tokens,
       cache_read_tokens, cache_write_tokens, thinking_tokens,
@@ -6847,6 +7872,7 @@ function insertSyncedRecord(db, record) {
     sourceFile: record.sourceFile ?? "",
     cwd: record.cwd ?? ""
   });
+  return result.changes > 0;
 }
 function mergeSyncedRecordsIntoRecords(db) {
   const now = Date.now();
@@ -6907,6 +7933,7 @@ var RECORD_ID_SYNC_TOOLS = /* @__PURE__ */ new Set([
   "qoder",
   "cursor",
   "kilocode",
+  "kelivo",
   "goose",
   "zed",
   "kiro",
@@ -7015,15 +8042,15 @@ var SyncOrchestrator = class {
     });
     if (paths.length === 0) return 0;
     let totalPulled = 0;
-    for (const [index, path2] of paths.entries()) {
+    for (const [index, path3] of paths.entries()) {
       this.options.onProgress?.({
         phase: "pulling",
-        currentPath: path2,
+        currentPath: path3,
         completedFiles: index,
         totalFiles: paths.length,
         pulledCount: totalPulled
       });
-      const content = await this.backend.readFile(path2);
+      const content = await this.backend.readFile(path3);
       if (!content) continue;
       for (const line of content.split("\n").filter(Boolean)) {
         try {
@@ -7034,14 +8061,14 @@ var SyncOrchestrator = class {
           if (typeof record.updatedAt === "string") {
             record.updatedAt = new Date(record.updatedAt).getTime();
           }
-          insertSyncedRecord(this.db, record);
-          totalPulled++;
+          const changed = insertSyncedRecord(this.db, record);
+          if (changed) totalPulled++;
         } catch {
         }
       }
       this.options.onProgress?.({
         phase: "pulling",
-        currentPath: path2,
+        currentPath: path3,
         completedFiles: index + 1,
         totalFiles: paths.length,
         pulledCount: totalPulled
@@ -7049,13 +8076,13 @@ var SyncOrchestrator = class {
     }
     return totalPulled;
   }
-  async uploadFile(path2, localSyncRecords) {
-    const existingContent = await this.backend.readFile(path2);
+  async uploadFile(path3, localSyncRecords) {
+    const existingContent = await this.backend.readFile(path3);
     const existing = existingContent ? parseNdjson(existingContent) : /* @__PURE__ */ new Map();
     const changedCount = mergeRecords(existing, localSyncRecords);
     if (changedCount === 0) return 0;
     const content = Array.from(existing.values()).map((r) => JSON.stringify(r)).join("\n") + "\n";
-    await this.backend.writeFile(path2, content);
+    await this.backend.writeFile(path3, content);
     return changedCount;
   }
   async upload() {
@@ -7063,9 +8090,9 @@ var SyncOrchestrator = class {
     if (unsynced.length === 0) return 0;
     const byPath = /* @__PURE__ */ new Map();
     for (const record of unsynced) {
-      const path2 = getSyncPath(record.ts, this.options.deviceInstanceId);
-      if (!byPath.has(path2)) byPath.set(path2, []);
-      byPath.get(path2).push(record);
+      const path3 = getSyncPath(record.ts, this.options.deviceInstanceId);
+      if (!byPath.has(path3)) byPath.set(path3, []);
+      byPath.get(path3).push(record);
     }
     let totalUploaded = 0;
     const uploads = Array.from(byPath.entries());
@@ -7075,20 +8102,20 @@ var SyncOrchestrator = class {
       totalFiles: uploads.length,
       uploadedCount: 0
     });
-    for (const [index, [path2, localRecords]] of uploads.entries()) {
+    for (const [index, [path3, localRecords]] of uploads.entries()) {
       this.options.onProgress?.({
         phase: "uploading",
-        currentPath: path2,
+        currentPath: path3,
         completedFiles: index,
         totalFiles: uploads.length,
         uploadedCount: totalUploaded
       });
       const localSyncRecords = localRecords.map(mapStatsRecordToSyncRecord);
-      await this.uploadFile(path2, localSyncRecords);
+      await this.uploadFile(path3, localSyncRecords);
       totalUploaded += localRecords.length;
       this.options.onProgress?.({
         phase: "uploading",
-        currentPath: path2,
+        currentPath: path3,
         completedFiles: index + 1,
         totalFiles: uploads.length,
         uploadedCount: totalUploaded
@@ -7113,14 +8140,14 @@ var CloudSyncError = class extends Error {
   code;
   retryAfter;
 };
-function buildHeaders(method, path2, body) {
+function buildHeaders(method, path3, body) {
   const creds = loadCredentials();
   if (!creds) throw new CloudSyncError("Not logged in. Run `aiusage login` first.", "not_logged_in");
   const bodyHash = sha256(body);
   const timestamp = Date.now().toString();
   const nonce = generateNonce();
   const idempotencyKey = generateIdempotencyKey();
-  const canonical = buildCanonicalString(method, path2, bodyHash, timestamp, nonce, creds.device_id, idempotencyKey);
+  const canonical = buildCanonicalString(method, path3, bodyHash, timestamp, nonce, creds.device_id, idempotencyKey);
   const signature = computeHmac(creds.device_secret, canonical);
   return {
     "Content-Type": "application/json",
@@ -7179,9 +8206,9 @@ async function cloudPull(cursor, limit = 1e3) {
   if (cursor) params.set("cursor", cursor);
   params.set("limit", String(limit));
   const query = params.toString();
-  const path2 = `${SYNC_PULL_PATH}${query ? `?${query}` : ""}`;
+  const path3 = `${SYNC_PULL_PATH}${query ? `?${query}` : ""}`;
   const headers = buildHeaders("GET", SYNC_PULL_PATH, "");
-  const response = await fetch(`${serverUrl}${path2}`, { method: "GET", headers });
+  const response = await fetch(`${serverUrl}${path3}`, { method: "GET", headers });
   const data = await readJsonOrNull2(response);
   if (!response.ok) {
     const errObj = data?.error;
@@ -7198,12 +8225,32 @@ async function cloudPull(cursor, limit = 1e3) {
     syncGeneration: data.sync_generation || 1
   };
 }
+async function cloudClear() {
+  const serverUrl = getSiteUrl();
+  const creds = loadCredentials();
+  if (!creds) throw new CloudSyncError("Not logged in.", "not_logged_in");
+  const SYNC_CLEAR_PATH = "/api/cli/sync/clear";
+  const body = "{}";
+  const headers = buildHeaders("POST", SYNC_CLEAR_PATH, body);
+  const response = await fetch(`${serverUrl}${SYNC_CLEAR_PATH}`, { method: "POST", headers, body });
+  const data = await readJsonOrNull2(response);
+  if (!response.ok) {
+    const errObj = data?.error;
+    const errMsg = typeof errObj === "object" && errObj !== null ? errObj.message || `Clear failed (HTTP ${response.status})` : errObj || `Clear failed (HTTP ${response.status})`;
+    const errCode = typeof errObj === "object" && errObj !== null ? errObj.code || "server_error" : data?.error_code || "server_error";
+    throw new CloudSyncError(errMsg, errCode);
+  }
+  if (!data) throw new CloudSyncError("Invalid response from server", "invalid_response");
+  return {
+    syncGeneration: data.sync_generation || 1
+  };
+}
 function getClientVersion() {
   try {
-    const { readFileSync: readFileSync11 } = __require("fs");
+    const { readFileSync: readFileSync12 } = __require("fs");
     const { join: join16 } = __require("path");
     const pkgPath = join16(__dirname, "../../package.json");
-    const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
     return "0.0.0";
@@ -7293,7 +8340,7 @@ var CloudSyncOrchestrator = class {
 // src/sync/git.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { readFile, writeFile, mkdir, readdir, stat } from "fs/promises";
+import { readFile, writeFile, mkdir, readdir, stat, unlink, rm } from "fs/promises";
 import { join as join8 } from "path";
 var exec = promisify(execFile);
 var GitSyncBackend = class _GitSyncBackend {
@@ -7353,16 +8400,16 @@ var GitSyncBackend = class _GitSyncBackend {
       }
     }
   }
-  async readFile(path2) {
+  async readFile(path3) {
     try {
-      const fullPath = join8(this.dataDir, path2);
+      const fullPath = join8(this.dataDir, path3);
       return await readFile(fullPath, "utf-8");
     } catch {
       return null;
     }
   }
-  async writeFile(path2, content) {
-    const fullPath = join8(this.dataDir, path2);
+  async writeFile(path3, content) {
+    const fullPath = join8(this.dataDir, path3);
     await mkdir(join8(fullPath, ".."), { recursive: true });
     await writeFile(fullPath, content, "utf-8");
   }
@@ -7373,6 +8420,22 @@ var GitSyncBackend = class _GitSyncBackend {
       return [];
     }
   }
+  async deleteFile(path3) {
+    const fullPath = join8(this.dataDir, path3);
+    try {
+      await unlink(fullPath);
+    } catch {
+    }
+  }
+  async deleteAllData() {
+    try {
+      const files = await this.listFiles();
+      await rm(this.dataDir, { recursive: true, force: true });
+      return files.length;
+    } catch {
+      return 0;
+    }
+  }
   static MAX_PUSH_RETRIES = 3;
   /** Commit and push all changes. Returns true if anything was pushed. */
   async flush() {
@@ -7407,7 +8470,7 @@ var GitSyncBackend = class _GitSyncBackend {
 };
 
 // src/sync/s3.ts
-import { S3Client, GetObjectCommand, PutObjectCommand, HeadObjectCommand, ListObjectsV2Command } from "@aws-sdk/client-s3";
+import { S3Client, GetObjectCommand, PutObjectCommand, HeadObjectCommand, ListObjectsV2Command, DeleteObjectCommand, DeleteObjectsCommand } from "@aws-sdk/client-s3";
 var S3SyncBackend = class {
   client;
   bucket;
@@ -7424,11 +8487,11 @@ var S3SyncBackend = class {
       }
     });
   }
-  getObjectKey(path2) {
-    return `${this.prefix}${path2}`;
+  getObjectKey(path3) {
+    return `${this.prefix}${path3}`;
   }
-  async readFile(path2) {
-    const key = this.getObjectKey(path2);
+  async readFile(path3) {
+    const key = this.getObjectKey(path3);
     try {
       const command = new GetObjectCommand({
         Bucket: this.bucket,
@@ -7444,8 +8507,8 @@ var S3SyncBackend = class {
       throw error;
     }
   }
-  async writeFile(path2, content) {
-    const key = this.getObjectKey(path2);
+  async writeFile(path3, content) {
+    const key = this.getObjectKey(path3);
     const command = new PutObjectCommand({
       Bucket: this.bucket,
       Key: key,
@@ -7477,8 +8540,8 @@ var S3SyncBackend = class {
     } while (continuationToken);
     return files.sort();
   }
-  async fileExists(path2) {
-    const key = this.getObjectKey(path2);
+  async fileExists(path3) {
+    const key = this.getObjectKey(path3);
     try {
       const command = new HeadObjectCommand({
         Bucket: this.bucket,
@@ -7493,6 +8556,31 @@ var S3SyncBackend = class {
       throw error;
     }
   }
+  async deleteFile(path3) {
+    const key = this.getObjectKey(path3);
+    const command = new DeleteObjectCommand({
+      Bucket: this.bucket,
+      Key: key
+    });
+    await this.client.send(command);
+  }
+  async deleteAllData() {
+    const files = await this.listFiles();
+    if (files.length === 0) return 0;
+    const BATCH_SIZE2 = 1e3;
+    for (let i = 0; i < files.length; i += BATCH_SIZE2) {
+      const batch = files.slice(i, i + BATCH_SIZE2);
+      const command = new DeleteObjectsCommand({
+        Bucket: this.bucket,
+        Delete: {
+          Objects: batch.map((f) => ({ Key: this.getObjectKey(f) })),
+          Quiet: true
+        }
+      });
+      await this.client.send(command);
+    }
+    return files.length;
+  }
 };
 
 // src/commands/sync.ts
@@ -7601,6 +8689,8 @@ async function runSync(db, options) {
 }
 
 // src/commands/clean.ts
+import { unlinkSync as unlinkSync2, existsSync as existsSync9 } from "fs";
+import { join as join10 } from "path";
 function cleanOldData(db, days) {
   const cutoff = Date.now() - days * 864e5;
   const recordsResult = db.prepare("DELETE FROM records WHERE ts < ?").run(cutoff);
@@ -7615,6 +8705,172 @@ function cleanOldData(db, days) {
     deletedOrphanToolCalls
   };
 }
+function cleanAll(db) {
+  const recordsResult = db.prepare("DELETE FROM records").run();
+  const toolCallsResult = db.prepare("DELETE FROM tool_calls").run();
+  const syncedResult = db.prepare("DELETE FROM synced_records").run();
+  const syncStateResult = db.prepare("DELETE FROM sync_record_state").run();
+  const tombstonesResult = db.prepare("DELETE FROM sync_tombstones").run();
+  const watermarkPath = join10(AIUSAGE_DIR, "watermark.json");
+  let watermarkRemoved = false;
+  if (existsSync9(watermarkPath)) {
+    unlinkSync2(watermarkPath);
+    watermarkRemoved = true;
+  }
+  return {
+    deletedRecords: recordsResult.changes,
+    deletedToolCalls: toolCallsResult.changes,
+    deletedSyncedRecords: syncedResult.changes,
+    deletedSyncRecordState: syncStateResult.changes,
+    deletedTombstones: tombstonesResult.changes,
+    watermarkRemoved
+  };
+}
+function getRemoteBackends() {
+  const config = loadConfig();
+  if (!config?.sync) return [];
+  const backends = [];
+  if (config.sync.backend === "cloud") {
+    backends.push({ type: "cloud", label: "AIUsage Cloud (cloud)" });
+  } else if (config.sync.backend === "github" && config.sync.repo) {
+    backends.push({ type: "github", label: `GitHub (${config.sync.repo})` });
+  } else if (config.sync.backend === "s3" && config.sync.bucket) {
+    backends.push({ type: "s3", label: `S3 (${config.sync.bucket})` });
+  }
+  return backends;
+}
+function createBackend2(config) {
+  if (!config?.sync) return null;
+  if (config.sync.backend === "github") {
+    if (!config.sync.repo) return null;
+    const token = loadCredential(`github/${config.sync.repo}/token`);
+    if (!token) return null;
+    return new GitSyncBackend({
+      repo: config.sync.repo,
+      token,
+      cacheDir: join10(AIUSAGE_DIR, "sync-repo")
+    });
+  }
+  if (config.sync.backend === "s3") {
+    if (!config.sync.bucket) return null;
+    const accessKeyId = loadCredential(`s3/${config.sync.bucket}/accessKeyId`);
+    const secretAccessKey = loadCredential(`s3/${config.sync.bucket}/secretAccessKey`);
+    if (!accessKeyId || !secretAccessKey) return null;
+    return new S3SyncBackend({
+      bucket: config.sync.bucket,
+      prefix: config.sync.prefix ?? "aiusage/",
+      accessKeyId,
+      secretAccessKey,
+      endpoint: config.sync.endpoint,
+      region: config.sync.region
+    });
+  }
+  return null;
+}
+async function propagateClean(options) {
+  const config = loadConfig();
+  if (!config?.sync) return { backends: [] };
+  const results = [];
+  if (config.sync.backend === "cloud") {
+    if (!options.target || options.target === "cloud") {
+      try {
+        const result = await cloudClear();
+        results.push({
+          backend: { type: "cloud", label: "AIUsage Cloud" },
+          status: "ok",
+          detail: `generation updated to ${result.syncGeneration}`
+        });
+      } catch (err) {
+        results.push({
+          backend: { type: "cloud", label: "AIUsage Cloud" },
+          status: "skipped",
+          detail: err instanceof Error ? err.message : "unknown error"
+        });
+      }
+    }
+    return { backends: results };
+  }
+  if (options.target && options.target !== config.sync.backend) {
+    return { backends: results };
+  }
+  const backend = createBackend2(config);
+  if (!backend) {
+    return { backends: [{
+      backend: { type: config.sync.backend, label: config.sync.backend },
+      status: "skipped",
+      detail: "Could not create backend (missing credentials)"
+    }] };
+  }
+  try {
+    await backend.prepare?.();
+    if (options.all) {
+      const files = await backend.listFiles();
+      const fileCount = files.length;
+      if (fileCount > 0) {
+        await backend.deleteAllData();
+      }
+      await backend.flush?.();
+      results.push({
+        backend: {
+          type: config.sync.backend,
+          label: config.sync.backend === "github" ? `GitHub (${config.sync.repo})` : `S3 (${config.sync.bucket})`
+        },
+        status: "ok",
+        detail: `cleared ${fileCount} files`
+      });
+    } else if (options.beforeDays) {
+      const cutoff = Date.now() - options.beforeDays * 864e5;
+      const files = await backend.listFiles();
+      let removedRecords = 0;
+      let modifiedFiles = 0;
+      for (const file of files) {
+        const content = await backend.readFile(file);
+        if (!content) continue;
+        const lines = content.split("\n").filter(Boolean);
+        const kept = [];
+        for (const line of lines) {
+          try {
+            const record = JSON.parse(line);
+            const ts3 = typeof record.ts === "string" ? new Date(record.ts).getTime() : record.ts;
+            if (ts3 >= cutoff) {
+              kept.push(line);
+            } else {
+              removedRecords++;
+            }
+          } catch {
+            kept.push(line);
+          }
+        }
+        if (kept.length === 0) {
+          await backend.deleteFile?.(file);
+          modifiedFiles++;
+        } else if (kept.length < lines.length) {
+          await backend.writeFile(file, kept.join("\n") + "\n");
+          modifiedFiles++;
+        }
+      }
+      await backend.flush?.();
+      results.push({
+        backend: {
+          type: config.sync.backend,
+          label: config.sync.backend === "github" ? `GitHub (${config.sync.repo})` : `S3 (${config.sync.bucket})`
+        },
+        status: "ok",
+        detail: `removed ${removedRecords} records from ${modifiedFiles} files`
+      });
+    }
+  } catch (err) {
+    results.push({
+      backend: {
+        type: config.sync.backend,
+        label: config.sync.backend === "github" ? `GitHub (${config.sync.repo})` : `S3 (${config.sync.bucket})`
+      },
+      status: "skipped",
+      detail: err instanceof Error ? err.message : "unknown error"
+    });
+  }
+  return { backends: results };
+}
 
 // src/sync/runtime.ts
 var SyncRuntimeController = class {
@@ -7712,6 +8968,7 @@ var RuntimeSettingsController = class {
   leaderboardUploadTimer = null;
   syncTimer = null;
   parseInFlight = false;
+  cleanupInFlight = false;
   leaderboardUploadInFlight = false;
   started = false;
   constructor(options) {
@@ -7764,11 +9021,7 @@ var RuntimeSettingsController = class {
     }
     if (retentionDays > 0) {
       this.cleanupTimer = setInterval(() => {
-        try {
-          this.runCleanupFn(this.db, retentionDays);
-        } catch (err) {
-          console.error("[settings-controller] cleanup failed:", err);
-        }
+        void this.runCleanupSafely(retentionDays);
       }, this.cleanupIntervalMs);
     }
     if (config?.leaderboardAutoUpload === true && leaderboardUploadInterval > 0 && this.runLeaderboardUploadFn) {
@@ -7801,6 +9054,17 @@ var RuntimeSettingsController = class {
       this.parseInFlight = false;
     }
   }
+  async runCleanupSafely(retentionDays) {
+    if (this.cleanupInFlight) return;
+    this.cleanupInFlight = true;
+    try {
+      await this.runCleanupFn(this.db, retentionDays);
+    } catch (err) {
+      console.error("[settings-controller] cleanup failed:", err);
+    } finally {
+      this.cleanupInFlight = false;
+    }
+  }
   async runLeaderboardUploadSafely() {
     if (this.leaderboardUploadInFlight) return;
     this.leaderboardUploadInFlight = true;
@@ -7817,7 +9081,7 @@ var RuntimeSettingsController = class {
 
 // src/commands/serve.ts
 var MAX_PORT_ATTEMPTS = 10;
-var PORT_FILE = join10(AIUSAGE_DIR, ".serve-port");
+var PORT_FILE = join11(AIUSAGE_DIR, ".serve-port");
 var MIME_TYPES = {
   ".html": "text/html",
   ".js": "application/javascript",
@@ -7832,11 +9096,8 @@ var MIME_TYPES = {
 };
 function serve(options) {
   const config = loadConfig();
-  if (config?.priceOverrides) {
-    for (const [model, entry] of Object.entries(config.priceOverrides)) {
-      setPriceOverride(model, entry);
-    }
-  }
+  const dbWriteQueue = new AsyncTaskQueue();
+  const runDbWrite = (task) => dbWriteQueue.run(task);
   if (config == null || config.exchangeRate == null) {
     const cacheAge = config?.exchangeRateCache ? Date.now() - config.exchangeRateCache.fetchedAt : Infinity;
     if (cacheAge >= CACHE_TTL_MS) {
@@ -7852,8 +9113,10 @@ function serve(options) {
   }
   const syncRuntime = new SyncRuntimeController({
     runSync: async (runtimeOptions) => {
-      await runParse(options.db);
-      await runSync(options.db, runtimeOptions);
+      await runDbWrite(async () => {
+        await runParse(options.db);
+        await runSync(options.db, runtimeOptions);
+      });
     },
     getPersistedState: () => getState(AIUSAGE_DIR),
     getCurrentTarget: () => getSyncTarget(loadConfig()?.sync)
@@ -7861,14 +9124,14 @@ function serve(options) {
   const runtimeSettings = new RuntimeSettingsController({
     db: options.db,
     loadConfig,
-    runParse,
-    runCleanup: cleanOldData,
+    runParse: (db) => runDbWrite(() => runParse(db)),
+    runCleanup: (db, retentionDays) => runDbWrite(() => cleanOldData(db, retentionDays)),
     runLeaderboardUpload: (db) => uploadLeaderboardData(db, getState(AIUSAGE_DIR)?.deviceInstanceId).then(() => void 0),
     runSync: () => syncRuntime.start(),
     onSyncScheduleChanged: (ts3) => syncRuntime.setNextSyncAt(ts3)
   });
   runtimeSettings.start();
-  runParse(options.db).catch((err) => {
+  runDbWrite(() => runParse(options.db)).catch((err) => {
     console.error("[serve] initial parse failed:", err);
   });
   const apiServer = createApiServer(options.db, {
@@ -7876,14 +9139,16 @@ function serve(options) {
     onRefresh: () => runParse(options.db),
     onSyncStart: () => syncRuntime.start(),
     getSyncStatus: () => syncRuntime.getStatus(),
-    onConfigUpdated: () => runtimeSettings.reload()
+    onConfigUpdated: () => runtimeSettings.reload(),
+    runDbWrite,
+    getDbWriteQueueStatus: () => dbWriteQueue.getStatus()
   });
   const webBuildDir = (() => {
-    const prodDir = join10(dirname3(fileURLToPath(import.meta.url)), "web");
-    if (existsSync9(prodDir)) return prodDir;
-    return join10(dirname3(fileURLToPath(import.meta.url)), "..", "..", "..", "web", "build");
+    const prodDir = join11(dirname4(fileURLToPath(import.meta.url)), "web");
+    if (existsSync10(prodDir)) return prodDir;
+    return join11(dirname4(fileURLToPath(import.meta.url)), "..", "..", "..", "web", "build");
   })();
-  if (!existsSync9(webBuildDir)) {
+  if (!existsSync10(webBuildDir)) {
     console.error("Web dashboard not found. Reinstall the package: npm install -g @juliantanx/aiusage");
     process.exit(1);
   }
@@ -7893,19 +9158,19 @@ function serve(options) {
       apiServer.emit("request", req, res);
       return;
     }
-    if (existsSync9(webBuildDir)) {
-      let filePath = join10(webBuildDir, url.pathname);
+    if (existsSync10(webBuildDir)) {
+      let filePath = join11(webBuildDir, url.pathname);
       try {
         if (statSync3(filePath).isDirectory()) {
-          filePath = join10(filePath, "index.html");
+          filePath = join11(filePath, "index.html");
         }
       } catch {
       }
-      if (!existsSync9(filePath)) {
-        filePath = join10(webBuildDir, "index.html");
+      if (!existsSync10(filePath)) {
+        filePath = join11(webBuildDir, "index.html");
       }
       try {
-        const content = readFileSync8(filePath);
+        const content = readFileSync9(filePath);
         const ext = extname2(filePath);
         const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
         res.writeHead(200, { "Content-Type": contentType });
@@ -7925,7 +9190,7 @@ function serve(options) {
   };
   server.on("listening", () => {
     started = true;
-    writeFileSync5(PORT_FILE, String(currentPort), "utf-8");
+    writeFileSync6(PORT_FILE, String(currentPort), "utf-8");
     console.log(`aiusage serve listening on http://localhost:${currentPort}`);
   });
   server.on("error", (error) => {
@@ -7943,7 +9208,7 @@ function serve(options) {
   listenOnPort(options.port);
   const cleanup = () => {
     try {
-      unlinkSync2(PORT_FILE);
+      unlinkSync3(PORT_FILE);
     } catch {
     }
   };
@@ -8087,9 +9352,9 @@ Consent recorded for schema v1.`
 }
 
 // src/commands/status.ts
-import { statSync as statSync4, existsSync as existsSync10 } from "fs";
+import { statSync as statSync4, existsSync as existsSync11 } from "fs";
 import { hostname as hostname3 } from "os";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 function formatFileSize(bytes) {
   if (bytes < 1024) return `${bytes} B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
@@ -8107,9 +9372,9 @@ function generateStatus(db) {
   const schemaVersion = db.prepare("SELECT version FROM schema_version ORDER BY version DESC LIMIT 1").get()?.version ?? 0;
   const tableCount = db.prepare("SELECT COUNT(*) as count FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'").get()?.count ?? 0;
   const viewCount = db.prepare("SELECT COUNT(*) as count FROM sqlite_master WHERE type = 'view'").get()?.count ?? 0;
-  const sizePath = join11(AIUSAGE_DIR, "cache.db");
+  const sizePath = join12(AIUSAGE_DIR, "cache.db");
   let databaseSize = "0 B";
-  if (existsSync10(sizePath)) {
+  if (existsSync11(sizePath)) {
     try {
       const stat2 = statSync4(sizePath);
       databaseSize = formatFileSize(stat2.size);
@@ -8186,27 +9451,6 @@ function exportData(db, format) {
   return lines.join("\n");
 }
 
-// src/commands/reset.ts
-import { unlinkSync as unlinkSync3, existsSync as existsSync11 } from "fs";
-import { join as join12 } from "path";
-function runReset(db) {
-  const recordsResult = db.prepare("DELETE FROM records").run();
-  const toolCallsResult = db.prepare("DELETE FROM tool_calls").run();
-  const syncedResult = db.prepare("DELETE FROM synced_records").run();
-  const watermarkPath = join12(AIUSAGE_DIR, "watermark.json");
-  let watermarkRemoved = false;
-  if (existsSync11(watermarkPath)) {
-    unlinkSync3(watermarkPath);
-    watermarkRemoved = true;
-  }
-  return {
-    deletedRecords: recordsResult.changes,
-    deletedToolCalls: toolCallsResult.changes,
-    deletedSyncedRecords: syncedResult.changes,
-    watermarkRemoved
-  };
-}
-
 // src/commands/recalc.ts
 var BATCH_SIZE = 1e3;
 function recalcPricing(db) {
@@ -8227,15 +9471,15 @@ function recalcPricing(db) {
       }
       const model = record.tool === "qoder" ? normalizeQoderModel(record.model) : record.model;
       const provider = model !== record.model ? inferProvider(model) : record.provider;
-      const hasPrice = resolvePrice(model) != null;
-      const newCost = hasPrice ? calculateCost(model, {
+      const price = resolvePriceFromRegistry(db, model);
+      const newCost = price ? calculateCostForPrice(price, {
         inputTokens: record.input_tokens,
         outputTokens: record.output_tokens,
         cacheReadTokens: record.cache_read_tokens,
         cacheWriteTokens: record.cache_write_tokens,
         thinkingTokens: record.thinking_tokens
       }, exchangeRate) : 0;
-      const costSource = hasPrice ? "pricing" : "unknown";
+      const costSource = price ? "pricing" : "unknown";
       if (model !== record.model || provider !== record.provider || newCost !== record.cost || costSource !== record.cost_source) {
         updateStmt.run(model, provider, newCost, costSource, Date.now(), record.id);
         updatedCount++;
@@ -8319,7 +9563,7 @@ var SyncProgressReporter = class {
 };
 
 // src/commands/widget.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
 import { spawn, execSync as execSync2 } from "child_process";
 import { join as join13 } from "path";
 var WIDGET_PID_PATH = join13(AIUSAGE_DIR, "widget.pid");
@@ -8347,7 +9591,7 @@ function isWidgetRunning() {
   if (!existsSync12(WIDGET_PID_PATH)) return false;
   let pid;
   try {
-    pid = parseInt(readFileSync9(WIDGET_PID_PATH, "utf-8").trim(), 10);
+    pid = parseInt(readFileSync10(WIDGET_PID_PATH, "utf-8").trim(), 10);
   } catch {
     return false;
   }
@@ -8391,10 +9635,10 @@ function getDeviceName2() {
 }
 function getCliVersion2() {
   try {
-    const { readFileSync: readFileSync11 } = __require("fs");
+    const { readFileSync: readFileSync12 } = __require("fs");
     const { join: join16 } = __require("path");
     const pkgPath = join16(__dirname, "../../package.json");
-    const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
     return "0.0.0";
@@ -8638,7 +9882,7 @@ async function runLeaderboardView(options = {}) {
 // src/commands/menu.ts
 import { createInterface } from "readline";
 import { spawn as spawn2, spawnSync, execSync as execSync4 } from "child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync11 } from "fs";
 import { join as join14 } from "path";
 var DEFAULT_PORT = 3847;
 var PORT_FILE2 = join14(AIUSAGE_DIR, ".serve-port");
@@ -8647,7 +9891,7 @@ function clearScreen() {
 }
 function getPort() {
   if (existsSync13(PORT_FILE2)) {
-    const raw = readFileSync10(PORT_FILE2, "utf-8").trim();
+    const raw = readFileSync11(PORT_FILE2, "utf-8").trim();
     const n = parseInt(raw, 10);
     if (!isNaN(n) && n > 0) return n;
   }
@@ -8825,11 +10069,10 @@ async function dataSubmenu(rl) {
   [2] Summary
   [3] Export
   [4] Clean
-  [5] Reset
-  [6] Recalc
+  [5] Recalc
   [0] Back
 `);
-    const choice = await prompt(rl, "  Select [0-6]: ");
+    const choice = await prompt(rl, "  Select [0-5]: ");
     switch (choice) {
       case "1": {
         const progress = await prompt(rl, "  Show progress? [Y/N]: ");
@@ -8865,28 +10108,28 @@ async function dataSubmenu(rl) {
         break;
       }
       case "4": {
-        const dur = await prompt(rl, "  Duration to keep (default 180d): ");
-        const before = dur || "180d";
+        const mode = await prompt(rl, "  1=Old data (180d)  2=Old data (custom)  3=All (=reset): ");
         console.log("");
-        runCommand(["clean", "--before", before, "--yes"]);
-        await prompt(rl, "\n  Press Enter to continue...");
-        break;
-      }
-      case "5": {
-        const confirm = await prompt(
-          rl,
-          '  WARNING: This will delete ALL parsed data. Type "yes" to confirm: '
-        );
-        if (confirm.toLowerCase() === "yes") {
-          console.log("");
-          runCommand(["reset", "--yes"]);
+        if (mode === "3") {
+          const confirm = await prompt(
+            rl,
+            '  WARNING: This will delete ALL parsed data. Type "confirm" to proceed: '
+          );
+          if (confirm.toLowerCase() === "confirm") {
+            runCommand(["clean", "--all", "--yes"]);
+          } else {
+            console.log("  Cancelled.");
+          }
+        } else if (mode === "2") {
+          const dur = await prompt(rl, "  Duration to keep (e.g. 30d, 90d): ");
+          runCommand(["clean", "--before", dur || "180d", "--yes"]);
         } else {
-          console.log("\n  Cancelled.");
+          runCommand(["clean", "--before", "180d", "--yes"]);
         }
         await prompt(rl, "\n  Press Enter to continue...");
         break;
       }
-      case "6": {
+      case "5": {
         console.log("");
         runCommand(["recalc"]);
         await prompt(rl, "\n  Press Enter to continue...");
@@ -9101,7 +10344,7 @@ async function runMenu() {
 ${dashboardStatusLine()}
 
   [1] Dashboard      (serve/stop/restart/open)
-  [2] Data           (parse/summary/export/clean/reset/recalc)
+  [2] Data           (parse/summary/export/clean/recalc)
   [3] Sync           (init/sync)
   [4] Leaderboard    (view/login/upload/status/logout)
   [5] System         (status/widget/pm2/update)
@@ -9140,7 +10383,7 @@ ${dashboardStatusLine()}
 import { join as join15 } from "path";
 var DB_PATH2 = join15(AIUSAGE_DIR, "cache.db");
 var program = new Command();
-program.name("aiusage").version(true ? "1.5.1" : "dev").description("CLI tool for AI usage statistics");
+program.name("aiusage").version(true ? "1.5.3" : "dev").description("CLI tool for AI usage statistics");
 program.action(() => {
   const unknownCommand = program.args.find((arg) => typeof arg === "string");
   if (unknownCommand) {
@@ -9222,7 +10465,7 @@ program.command("export").description("Export data").requiredOption("--format <f
   const db = createDatabase(DB_PATH2);
   const data = exportData(db, format);
   if (options.output) {
-    writeFileSync6(options.output, data, "utf-8");
+    writeFileSync7(options.output, data, "utf-8");
     console.log(`Exported to ${options.output}`);
   } else {
     console.log(data);
@@ -9249,32 +10492,109 @@ program.command("parse").description("Parse AI tool session logs").option("--too
     db.close();
   }
 });
-program.command("clean").description("Clean old data").option("--before <duration>", "Duration (e.g., 30d)", "180d").option("--remote", "Also clean remote data").option("--all-devices", "Clean all devices (with --remote)").option("--yes", "Skip confirmation").option("--approve-delete", "Approve delete permission upgrade").action((options) => {
-  const daysMatch = options.before.match(/^(\d+)d$/);
-  if (!daysMatch) {
-    console.error("Invalid duration format. Use e.g. 30d, 180d.");
+program.command("clean").description("Clean data (old records or all data)").option("--before <duration>", "Delete data older than this (e.g., 30d, 180d)", "180d").option("--all", "Wipe all data (equivalent to former reset: all records, tool calls, watermark)").option("--local-only", "Only clean local data, do not propagate to remote backends").option("--target <backend>", "Target specific remote backend (github/s3/cloud)").option("--yes", "Skip local confirmation (remote deletion still requires confirmation)").action(async (options) => {
+  const isAll = !!options.all;
+  const localOnly = !!options.localOnly;
+  let days = 0;
+  if (isAll && options.before !== "180d") {
+    console.error("Cannot use --all and --before together. Use one or the other.");
     process.exit(1);
   }
-  const days = parseInt(daysMatch[1], 10);
-  const db = createDatabase(DB_PATH2);
-  const result = cleanOldData(db, days);
-  console.log(`Deleted ${result.deletedCount} records, ${result.deletedSyncedCount} synced records, ${result.deletedOrphanToolCalls} orphan tool calls.`);
-  db.close();
-});
-program.command("reset").description("Delete all parsed data and watermark, then re-parse from scratch").option("--yes", "Skip confirmation").action((options) => {
+  if (!isAll) {
+    const daysMatch = options.before.match(/^(\d+)d$/);
+    if (!daysMatch) {
+      console.error("Invalid duration format. Use e.g. 30d, 180d.");
+      process.exit(1);
+    }
+    days = parseInt(daysMatch[1], 10);
+  }
+  const remoteBackends = localOnly ? [] : getRemoteBackends();
+  if (isAll) {
+    console.log("\x1B[33m\u26A0 WARNING: This will delete ALL parsed data, tool calls, synced records,\x1B[0m");
+    console.log("\x1B[33m  and the parse watermark. Next parse will re-import from scratch.\x1B[0m");
+  } else {
+    console.log(`This will delete local records older than ${days} days.`);
+  }
+  if (localOnly) {
+    console.log("\x1B[36m  (--local-only: remote data will NOT be affected)\x1B[0m");
+  }
+  if (remoteBackends.length > 0) {
+    console.log("\nCloud sync is configured. The following remote backends will also be affected:");
+    for (const rb of remoteBackends) {
+      console.log(`  - ${rb.label}`);
+    }
+  }
+  const ask = async (question) => {
+    if (!process.stdin.isTTY) {
+      console.error("Non-interactive mode detected. Use --local-only to skip remote propagation, or run interactively.");
+      process.exit(1);
+    }
+    const { createInterface: createInterface2 } = await import("readline");
+    const rl = createInterface2({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve2) => {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve2(answer.trim());
+      });
+    });
+  };
   if (!options.yes) {
-    console.error("This will delete ALL parsed records, tool calls, synced data, and the parse watermark.");
-    console.error("Source log files (~/.claude, ~/.codex, etc.) will NOT be affected.");
-    console.error("Use --yes to confirm.");
-    process.exit(1);
+    if (remoteBackends.length > 0) {
+      const answer = await ask(`
+? Confirm deletion on local + ${remoteBackends.length} remote backend(s)? [y/N] `);
+      if (answer.toLowerCase() !== "y") {
+        console.log("Cancelled.");
+        process.exit(0);
+      }
+    } else {
+      const answer = await ask("\n? Confirm? [y/N] ");
+      if (answer.toLowerCase() !== "y") {
+        console.log("Cancelled.");
+        process.exit(0);
+      }
+    }
+  } else if (remoteBackends.length > 0) {
+    const answer = await ask('\n? Type "confirm" to proceed with remote deletion: ');
+    if (answer !== "confirm") {
+      console.log("Cancelled.");
+      process.exit(0);
+    }
   }
   const db = createDatabase(DB_PATH2);
-  const result = runReset(db);
-  console.log(`Deleted ${result.deletedRecords} records, ${result.deletedToolCalls} tool calls, ${result.deletedSyncedRecords} synced records.`);
-  if (result.watermarkRemoved) {
-    console.log("Watermark removed \u2014 next parse will re-import all data from scratch.");
+  if (isAll) {
+    console.log("\nDeleting all local data...");
+    const result = cleanAll(db);
+    console.log(`  Local: deleted ${result.deletedRecords} records, ${result.deletedToolCalls} tool calls, ${result.deletedSyncedRecords} synced records`);
+    if (result.watermarkRemoved) {
+      console.log("  Watermark removed");
+    }
+  } else {
+    console.log(`
+Cleaning local records older than ${days} days...`);
+    const result = cleanOldData(db, days);
+    console.log(`  Local: deleted ${result.deletedCount} records, ${result.deletedSyncedCount} synced records, ${result.deletedOrphanToolCalls} orphan tool calls`);
   }
   db.close();
+  if (remoteBackends.length > 0) {
+    console.log("\nSyncing deletion to remote backends...");
+    try {
+      const propagation = await propagateClean({
+        all: isAll,
+        beforeDays: isAll ? void 0 : days,
+        target: options.target
+      });
+      for (const r of propagation.backends) {
+        if (r.status === "ok") {
+          console.log(`  ${r.backend.label}: ${r.detail}`);
+        } else {
+          console.log(`  ${r.backend.label}: skipped \u2014 ${r.detail}`);
+        }
+      }
+    } catch (err) {
+      console.error(`  Propagation failed: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+  console.log("\nDone.");
 });
 program.command("recalc").description("Recalculate costs").option("--pricing", "Recalculate using latest pricing").action(() => {
   const db = createDatabase(DB_PATH2);
@@ -9351,7 +10671,7 @@ function hasWidget() {
 }
 function buildPm2Config(includeWidget) {
   const wrapperPath = join15(AIUSAGE_DIR, "pm2-server.cjs");
-  writeFileSync6(wrapperPath, [
+  writeFileSync7(wrapperPath, [
     `// Auto-generated by aiusage pm2-start \u2014 do not edit`,
     `const { execSync, spawn } = require('child_process')`,
     `const { dirname, join } = require('path')`,
@@ -9398,7 +10718,7 @@ program.command("pm2-setup").description("Generate ecosystem.config.cjs for PM2
   const includeWidget = options.serverOnly ? false : hasWidget();
   const config = buildPm2Config(includeWidget);
   const configPath = join15(AIUSAGE_DIR, "ecosystem.config.cjs");
-  writeFileSync6(configPath, config, "utf-8");
+  writeFileSync7(configPath, config, "utf-8");
   console.log(`Config created: ${configPath}`);
   if (!includeWidget) {
     console.log("Note: aiusage-widget not found, only server is configured.");
@@ -9408,7 +10728,7 @@ program.command("pm2-start").description("Setup and start PM2 background service
   const includeWidget = options.serverOnly ? false : hasWidget();
   const config = buildPm2Config(includeWidget);
   const configPath = join15(AIUSAGE_DIR, "ecosystem.config.cjs");
-  writeFileSync6(configPath, config, "utf-8");
+  writeFileSync7(configPath, config, "utf-8");
   console.log(`Config: ${configPath}`);
   try {
     execSync5(`pm2 start "${configPath}"`, { stdio: "inherit" });