@juliantanx/aiusage 1.2.1 → 1.3.0

package/dist/index.js

@@ -1,19 +1,4 @@
 #!/usr/bin/env node
-import {
-  Aggregator,
-  DEFAULT_PRICE_TABLE,
-  calculateCost,
-  generateRecordId,
-  generateSessionKey,
-  generateSyncRecordId,
-  generateToolCallId,
-  getPriceTable,
-  getUserOverrides,
-  inferProvider,
-  removePriceOverride,
-  resolvePrice,
-  setPriceOverride
-} from "./chunk-2DX56FB6.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -27,7 +12,667 @@ import { fileURLToPath } from "url";
 
 // src/api/server.ts
 import http from "http";
-import { hostname, platform } from "os";
+import path2 from "path";
+import { hostname as hostname2, platform as platform2 } from "os";
+
+// ../core/dist/index.js
+import { createHash } from "crypto";
+var MODEL_PROVIDER_MAP = [
+  ["claude-", "anthropic"],
+  ["gpt-", "openai"],
+  ["o1-", "openai"],
+  ["o3-", "openai"],
+  ["o4-", "openai"],
+  ["o-", "openai"],
+  ["deepseek-", "deepseek"],
+  ["gemini-", "google"],
+  ["glm-", "zhipu"],
+  ["mimo-", "xiaomi"],
+  ["minimax-", "minimax"],
+  ["kimi-", "moonshot"],
+  ["qianfan-", "baidu"],
+  ["qwen", "alibaba"],
+  ["qoder-", "qoder"],
+  ["z-ai/", "zhipu"],
+  ["accounts/fireworks/", "fireworks"],
+  ["frank/", "zhipu"],
+  ["nvidia/", "nvidia"],
+  ["moonshotai/", "moonshot"],
+  ["zai-org/", "zhipu"]
+];
+function inferProvider(model) {
+  for (const [prefix, provider] of MODEL_PROVIDER_MAP) {
+    if (model.startsWith(prefix)) return provider;
+  }
+  return "unknown";
+}
+var FALLBACK_RATE = 0.137;
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+function resolveExchangeRate(config) {
+  if (config.exchangeRate != null) return config.exchangeRate;
+  if (config.exchangeRateCache) {
+    const age = Date.now() - config.exchangeRateCache.fetchedAt;
+    if (age < CACHE_TTL_MS) return config.exchangeRateCache.CNY_USD;
+  }
+  return FALLBACK_RATE;
+}
+async function fetchExchangeRate() {
+  try {
+    const response = await fetch("https://open.er-api.com/v6/latest/CNY", {
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    const rate = data?.rates?.USD;
+    if (typeof rate !== "number" || rate <= 0) return null;
+    return rate;
+  } catch {
+    return null;
+  }
+}
+function convertToUSD(cny, rate) {
+  return cny * rate;
+}
+var DEFAULT_PRICE_TABLE = {
+  // Anthropic — https://platform.claude.com/docs/en/about-claude/pricing
+  "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-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 },
+  // OpenAI — https://developers.openai.com/api/docs/pricing
+  "gpt-5.5-pro": { input: 30, output: 180 },
+  "gpt-5.5": { input: 5, output: 30 },
+  "gpt-5.4-pro": { input: 30, output: 180 },
+  "gpt-5.4-mini": { input: 0.75, output: 4.5 },
+  "gpt-5.4-nano": { input: 0.2, output: 1.25 },
+  "gpt-5.4": { input: 2.5, output: 15 },
+  "gpt-5.3-codex": { input: 1.75, output: 14 },
+  "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 },
+  "o3": { input: 2, output: 8 },
+  // Google Gemini — https://ai.google.dev/gemini-api/docs/pricing
+  "gemini-3.1-pro": { input: 2, output: 12 },
+  "gemini-3.1-flash-lite": { input: 0.25, output: 1.5 },
+  "gemini-3-flash": { input: 0.5, output: 3 },
+  "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": { input: 0.1, output: 0.4 },
+  // DeepSeek — https://api-docs.deepseek.com/quick_start/pricing
+  "deepseek-v4-pro": { input: 12.6, output: 25.2, cacheRead: 0.105, currency: "CNY" },
+  "deepseek-v4-flash": { input: 1, output: 2, cacheRead: 0.02, 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" },
+  "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" },
+  // MiniMax — https://platform.minimaxi.com/docs/guides/pricing-paygo
+  "minimax-m2.7": { input: 2.1, output: 8.4, cacheRead: 0.42, cacheWrite: 2.6, currency: "CNY" },
+  "minimax-m2.5": { input: 2.1, output: 8.4, cacheRead: 0.21, cacheWrite: 2.6, currency: "CNY" },
+  // Mistral AI — https://mistral.ai/pricing
+  "mistral-large": { input: 0.5, output: 1.5 },
+  "mistral-medium": { input: 0.4, output: 2 },
+  "mistral-small": { input: 0.1, output: 0.3 },
+  "codestral": { input: 0.3, output: 0.9 },
+  "open-mistral-nemo": { input: 0.02, output: 0.03 },
+  "open-mixtral-8x22b": { input: 1.2, output: 1.2 },
+  "ministral-8b": { input: 0.1, output: 0.1 },
+  "ministral-3b": { input: 0.04, output: 0.04 },
+  "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": { input: 1.25, output: 2.5 },
+  // Cohere — https://cohere.com/pricing
+  "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-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" },
+  // 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 userOverrides = {};
+var PRICE_TABLE = { ...DEFAULT_PRICE_TABLE };
+function getPriceTable() {
+  return { ...DEFAULT_PRICE_TABLE, ...userOverrides };
+}
+function setPriceOverride(model, entry) {
+  userOverrides = { ...userOverrides, [model]: entry };
+  PRICE_TABLE = { ...DEFAULT_PRICE_TABLE, ...userOverrides };
+}
+function removePriceOverride(model) {
+  const { [model]: _, ...rest } = userOverrides;
+  userOverrides = rest;
+  PRICE_TABLE = { ...DEFAULT_PRICE_TABLE, ...userOverrides };
+}
+function getUserOverrides() {
+  return { ...userOverrides };
+}
+var PROVIDER_PREFIXES = [
+  "accounts/fireworks/models/",
+  "moonshotai/",
+  "z-ai/",
+  "zai-org/",
+  "frank/",
+  "nvidia/"
+];
+function resolvePrice(model) {
+  if (PRICE_TABLE[model]) return PRICE_TABLE[model];
+  let stripped = model;
+  for (const prefix of PROVIDER_PREFIXES) {
+    if (stripped.startsWith(prefix)) {
+      stripped = stripped.slice(prefix.length);
+      break;
+    }
+  }
+  if (stripped !== model) {
+    const lc = stripped.toLowerCase();
+    if (PRICE_TABLE[lc]) return PRICE_TABLE[lc];
+    if (PRICE_TABLE[stripped]) return PRICE_TABLE[stripped];
+  }
+  let bestPrefix = "";
+  let bestEntry;
+  const candidates = [model, stripped, stripped.toLowerCase()];
+  for (const c of candidates) {
+    for (const [prefix, entry] of Object.entries(PRICE_TABLE)) {
+      if (c.startsWith(prefix) && prefix.length > bestPrefix.length) {
+        bestPrefix = prefix;
+        bestEntry = entry;
+      }
+    }
+  }
+  return bestEntry;
+}
+function calculateCost(model, tokens, exchangeRate) {
+  const price = resolvePrice(model);
+  if (!price) return 0;
+  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;
+  if (price.currency === "CNY") {
+    return convertToUSD(rawCost, exchangeRate ?? FALLBACK_RATE);
+  }
+  return rawCost;
+}
+var QODER_TIER_MODELS = /* @__PURE__ */ new Set([
+  "auto",
+  "ultimate",
+  "performance",
+  "efficient",
+  "lite"
+]);
+function normalizeQoderModel(model) {
+  const raw = model.trim();
+  if (!raw || raw.toLowerCase() === "unknown") return "unknown";
+  const lower = raw.toLowerCase();
+  const tier = lower.startsWith("qoder-") ? lower.slice("qoder-".length) : lower;
+  if (!tier) return "unknown";
+  if (QODER_TIER_MODELS.has(tier)) return `qoder-${tier}`;
+  return raw;
+}
+function generateRecordId(deviceInstanceId, sourceFile, lineOffset) {
+  const hash = createHash("sha256").update(deviceInstanceId + "\0" + sourceFile + "\0" + lineOffset).digest("hex");
+  return hash.slice(0, 16);
+}
+function generateSyncRecordId(deviceInstanceId, sourceFile, lineOffset) {
+  return generateRecordId(deviceInstanceId, sourceFile, lineOffset);
+}
+function generateToolCallId(recordId, name, ts, callIndex) {
+  const hash = createHash("sha256").update(recordId + "\0" + name + "\0" + ts + "\0" + callIndex).digest("hex");
+  return hash.slice(0, 16);
+}
+function generateOrphanToolCallId(tool, name, ts, callIndex) {
+  const hash = createHash("sha256").update(tool + "\0" + name + "\0" + ts + "\0" + callIndex).digest("hex");
+  return hash.slice(0, 16);
+}
+function generateSessionKey(device, sessionId) {
+  const hash = createHash("sha256").update(device + "\0" + sessionId).digest("hex");
+  return hash.slice(0, 24);
+}
+var ClaudeCodeParser = class {
+  tool = "claude-code";
+  parseLine(line, context) {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      return null;
+    }
+    if (!parsed.message?.usage) return null;
+    const usage = parsed.message.usage;
+    const model = parsed.message.model ?? "unknown";
+    if (model === "<synthetic>") return null;
+    const rawTs = parsed.message.timestamp ?? parsed.timestamp ?? context.now;
+    const ts = typeof rawTs === "number" ? rawTs : new Date(rawTs).getTime();
+    const inputTokens = usage.input_tokens ?? 0;
+    const outputTokens = usage.output_tokens ?? 0;
+    const cacheWriteTokens = usage.cache_creation_input_tokens ?? 0;
+    const cacheReadTokens = usage.cache_read_input_tokens ?? 0;
+    const thinkingTokens = usage.thinking_tokens ?? 0;
+    const cost = model === "unknown" ? 0 : calculateCost(model, {
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      thinkingTokens
+    }, context.exchangeRate);
+    const costSource = model === "unknown" ? "unknown" : "pricing";
+    const provider = inferProvider(model);
+    const record = {
+      id: generateRecordId(context.deviceInstanceId, context.sourceFile, context.lineOffset),
+      ts,
+      ingestedAt: context.now,
+      updatedAt: context.now,
+      lineOffset: context.lineOffset,
+      tool: this.tool,
+      model,
+      provider,
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      thinkingTokens,
+      cost,
+      costSource,
+      sessionId: context.sessionId,
+      sourceFile: context.sourceFile,
+      device: context.device,
+      deviceInstanceId: context.deviceInstanceId,
+      platform: context.platform
+    };
+    const toolCalls = [];
+    if (Array.isArray(parsed.message.content)) {
+      let callIndex = 0;
+      for (const block of parsed.message.content) {
+        if (block.type === "tool_use") {
+          const rawName = block.name ?? "";
+          const cleanName = rawName.replace(/[=:"'{\[\s].*$/s, "").replace(/[^a-zA-Z0-9_-]/g, "");
+          if (!cleanName) {
+            callIndex++;
+            continue;
+          }
+          toolCalls.push({
+            id: generateToolCallId(record.id, cleanName, ts, callIndex),
+            recordId: record.id,
+            name: cleanName,
+            ts,
+            callIndex
+          });
+          callIndex++;
+        }
+      }
+    }
+    return { record, toolCalls };
+  }
+};
+var CodexParser = class {
+  tool = "codex";
+  pendingToolCalls = [];
+  currentModel = null;
+  parseLine(line, context) {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      return null;
+    }
+    const payload = parsed.event_msg?.payload ?? (parsed.type === "event_msg" ? parsed.payload : void 0);
+    const turnCtx = parsed.type === "turn_context" ? parsed.payload : void 0;
+    if (turnCtx?.model) {
+      this.currentModel = turnCtx.model;
+    }
+    if (payload?.type === "turn_context" && payload.model) {
+      this.currentModel = payload.model;
+    }
+    if (!payload) return null;
+    if (payload.type !== "token_count" && payload.type !== "function_call") return null;
+    if (payload.type === "function_call") {
+      const rawFcTs = parsed.event_msg?.timestamp ?? parsed.timestamp ?? context.now;
+      this.pendingToolCalls.push({
+        name: payload.function?.name ?? "unknown",
+        ts: typeof rawFcTs === "number" ? rawFcTs : new Date(rawFcTs).getTime()
+      });
+      return null;
+    }
+    const usage = payload.last_token_usage ?? payload.info?.last_token_usage;
+    if (!usage) {
+      return null;
+    }
+    const model = payload.model ?? parsed.model ?? this.currentModel ?? "unknown";
+    const rawTs = parsed.event_msg?.timestamp ?? parsed.timestamp ?? context.now;
+    const ts = typeof rawTs === "number" ? rawTs : new Date(rawTs).getTime();
+    const inputTokens = usage.input_tokens ?? 0;
+    const outputTokens = usage.output_tokens ?? 0;
+    const cacheReadTokens = usage.cached_input_tokens ?? 0;
+    const thinkingTokens = usage.reasoning_output_tokens ?? 0;
+    const cacheWriteTokens = 0;
+    const cost = model === "unknown" ? 0 : calculateCost(model, {
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      thinkingTokens
+    }, context.exchangeRate);
+    const costSource = model === "unknown" ? "unknown" : "pricing";
+    const provider = inferProvider(model);
+    const recordId = generateRecordId(context.deviceInstanceId, context.sourceFile, context.lineOffset);
+    const record = {
+      id: recordId,
+      ts,
+      ingestedAt: context.now,
+      updatedAt: context.now,
+      lineOffset: context.lineOffset,
+      tool: this.tool,
+      model,
+      provider,
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      thinkingTokens,
+      cost,
+      costSource,
+      sessionId: context.sessionId,
+      sourceFile: context.sourceFile,
+      device: context.device,
+      deviceInstanceId: context.deviceInstanceId,
+      platform: context.platform
+    };
+    const toolCalls = this.pendingToolCalls.map((tc, callIndex) => ({
+      id: generateToolCallId(recordId, tc.name, tc.ts, callIndex),
+      recordId,
+      name: tc.name,
+      ts: tc.ts,
+      callIndex
+    }));
+    this.pendingToolCalls = [];
+    return { record, toolCalls };
+  }
+  finalize() {
+    if (this.pendingToolCalls.length === 0) return [];
+    const toolCalls = this.pendingToolCalls.map((tc, callIndex) => ({
+      id: generateOrphanToolCallId(this.tool, tc.name, tc.ts, callIndex),
+      recordId: null,
+      name: tc.name,
+      ts: tc.ts,
+      callIndex
+    }));
+    this.pendingToolCalls = [];
+    return [{ record: null, toolCalls }];
+  }
+};
+var OpenClawParser = class {
+  tool = "openclaw";
+  parseLine(line, context) {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      return null;
+    }
+    if (!parsed.message?.usage) return null;
+    const usage = parsed.message.usage;
+    const model = parsed.message.model ?? "unknown";
+    const rawTs = parsed.message.timestamp ?? context.now;
+    const ts = typeof rawTs === "number" ? rawTs : new Date(rawTs).getTime();
+    const inputTokens = usage.input ?? 0;
+    const outputTokens = usage.output ?? 0;
+    const cacheReadTokens = usage.cacheRead ?? 0;
+    const cacheWriteTokens = usage.cacheWrite ?? 0;
+    const thinkingTokens = 0;
+    let cost;
+    let costSource;
+    if (usage.cost != null && typeof usage.cost === "object") {
+      cost = usage.cost.total ?? 0;
+      costSource = "log";
+    } else if (typeof usage.cost === "number") {
+      cost = usage.cost;
+      costSource = "log";
+    } else if (model === "unknown") {
+      cost = 0;
+      costSource = "unknown";
+    } else {
+      cost = calculateCost(model, {
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheWriteTokens,
+        thinkingTokens
+      }, context.exchangeRate);
+      costSource = "pricing";
+    }
+    const provider = parsed.message.provider ?? inferProvider(model);
+    const record = {
+      id: generateRecordId(context.deviceInstanceId, context.sourceFile, context.lineOffset),
+      ts,
+      ingestedAt: context.now,
+      updatedAt: context.now,
+      lineOffset: context.lineOffset,
+      tool: this.tool,
+      model,
+      provider,
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      thinkingTokens,
+      cost,
+      costSource,
+      sessionId: context.sessionId,
+      sourceFile: context.sourceFile,
+      device: context.device,
+      deviceInstanceId: context.deviceInstanceId,
+      platform: context.platform
+    };
+    const toolCalls = [];
+    if (Array.isArray(parsed.message.content)) {
+      let callIndex = 0;
+      for (const block of parsed.message.content) {
+        if (block.type === "tool_use") {
+          toolCalls.push({
+            id: generateToolCallId(record.id, block.name, ts, callIndex),
+            recordId: record.id,
+            name: block.name,
+            ts,
+            callIndex
+          });
+          callIndex++;
+        }
+      }
+    }
+    return { record, toolCalls };
+  }
+};
+function toNumber(value) {
+  if (value == null) return 0;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : 0;
+}
+function toTimestamp(value, fallback) {
+  if (typeof value === "number") return value;
+  if (typeof value !== "string") return fallback;
+  const ts = new Date(value).getTime();
+  return Number.isFinite(ts) ? ts : fallback;
+}
+var QoderParser = class {
+  tool = "qoder";
+  pendingToolCallsByLoopId = /* @__PURE__ */ new Map();
+  parseLine(line, context) {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      return null;
+    }
+    if (parsed.type === "tool.requested") {
+      const loopId2 = parsed.loop_id ?? parsed.turn_id;
+      const toolName = parsed.data?.tool_name;
+      if (typeof loopId2 !== "string" || typeof toolName !== "string" || !toolName) {
+        return null;
+      }
+      const pending = this.pendingToolCallsByLoopId.get(loopId2) ?? [];
+      pending.push({
+        name: toolName,
+        ts: toTimestamp(parsed.ts, context.now)
+      });
+      this.pendingToolCallsByLoopId.set(loopId2, pending);
+      return null;
+    }
+    if (parsed.type !== "model.response.completed") return null;
+    const data = parsed.data;
+    if (!data || typeof data !== "object") return null;
+    const ts = toTimestamp(parsed.ts, context.now);
+    const rawModel = normalizeQoderModel(String(data.model ?? ""));
+    const model = rawModel === "unknown" ? "qoder-auto" : rawModel;
+    const inputTokens = toNumber(data.input_tokens);
+    const outputTokens = toNumber(data.output_tokens);
+    const cacheReadTokens = toNumber(data.cache_read_input_tokens ?? data.cache_read_tokens);
+    const cacheWriteTokens = toNumber(data.cache_creation_input_tokens ?? data.cache_write_input_tokens ?? data.cache_write_tokens);
+    const thinkingTokens = toNumber(data.thinking_tokens) || toNumber(data.reasoning_tokens) || toNumber(data.reasoning_output_tokens);
+    if (inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens + thinkingTokens === 0) {
+      return null;
+    }
+    const hasPrice = resolvePrice(model) != null;
+    const cost = hasPrice ? calculateCost(model, {
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      thinkingTokens
+    }, context.exchangeRate) : 0;
+    const costSource = hasPrice ? "pricing" : "unknown";
+    const recordId = generateRecordId(context.deviceInstanceId, context.sourceFile, context.lineOffset);
+    const record = {
+      id: recordId,
+      ts,
+      ingestedAt: context.now,
+      updatedAt: context.now,
+      lineOffset: context.lineOffset,
+      tool: this.tool,
+      model,
+      provider: inferProvider(model),
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      thinkingTokens,
+      cost,
+      costSource,
+      sessionId: context.sessionId,
+      sourceFile: context.sourceFile,
+      device: context.device,
+      deviceInstanceId: context.deviceInstanceId,
+      platform: context.platform
+    };
+    const loopId = parsed.loop_id ?? parsed.turn_id;
+    const pendingToolCalls = typeof loopId === "string" ? this.pendingToolCallsByLoopId.get(loopId) ?? [] : [];
+    if (typeof loopId === "string") {
+      this.pendingToolCallsByLoopId.delete(loopId);
+    }
+    const toolCalls = pendingToolCalls.map((tc, callIndex) => ({
+      id: generateToolCallId(recordId, tc.name, tc.ts, callIndex),
+      recordId,
+      name: tc.name,
+      ts: tc.ts,
+      callIndex
+    }));
+    return { record, toolCalls };
+  }
+  finalize() {
+    this.pendingToolCallsByLoopId.clear();
+    return [];
+  }
+};
+var Aggregator = class {
+  parsers;
+  activeParser = null;
+  constructor() {
+    this.parsers = /* @__PURE__ */ new Map([
+      ["claude-code", new ClaudeCodeParser()],
+      ["codex", new CodexParser()],
+      ["openclaw", new OpenClawParser()],
+      ["qoder", new QoderParser()]
+    ]);
+  }
+  createContext(options) {
+    return {
+      ...options,
+      now: Date.now()
+    };
+  }
+  parseLine(line, context) {
+    if (!this.activeParser || this.activeParser.tool !== context.tool) {
+      this.activeParser = this.parsers.get(context.tool) ?? null;
+    }
+    if (!this.activeParser) {
+      return null;
+    }
+    return this.activeParser.parseLine(line, context);
+  }
+  finalize() {
+    const results = [];
+    for (const parser of this.parsers.values()) {
+      if (parser.finalize) {
+        results.push(...parser.finalize());
+      }
+    }
+    return results;
+  }
+};
 
 // src/config.ts
 import { readFileSync, writeFileSync, existsSync } from "fs";
@@ -101,28 +746,39 @@ var GENERIC_DIRECTORY_NAMES = /* @__PURE__ */ new Set([
   ".codex",
   ".opencode",
   ".openclaw",
-  "projects"
+  ".qoder",
+  "projects",
+  "runs"
 ]);
 var TOOL_DIRECTORY_NAMES = /* @__PURE__ */ new Set(["agents", "main"]);
 function extractProject(sourceFile) {
   if (!sourceFile) return "unknown";
   return extractProjectFromClaudePath(sourceFile) ?? extractProjectFromKnownToolPath(sourceFile) ?? extractProjectFromGenericPath(sourceFile) ?? "unknown";
 }
+function decodeEncodedPath(raw) {
+  const parts = raw.split("-").filter(Boolean);
+  const WORKSPACE_ROOTS = ["WebstormProjects", "Documents", "Projects", "workspace", "Workspace"];
+  for (const root of WORKSPACE_ROOTS) {
+    const idx = parts.indexOf(root);
+    if (idx >= 0 && idx < parts.length - 1) {
+      return parts.slice(idx + 1).join("/");
+    }
+  }
+  const meaningful = parts.filter((p) => !looksMachineGenerated(p));
+  if (meaningful.length === 0) return raw;
+  if (meaningful.length <= 3) return meaningful[meaningful.length - 1] ?? "~";
+  return meaningful.slice(-2).join("/");
+}
 function extractProjectFromClaudePath(sourceFile) {
   const normalized = sourceFile.replace(/\\/g, "/");
   const match = normalized.match(/\.claude\/projects\/([^/]+)/);
   if (!match) return null;
-  const raw = match[1];
-  const parts = raw.split("-").filter(Boolean);
-  const webstormIndex = parts.indexOf("WebstormProjects");
-  if (webstormIndex >= 0 && webstormIndex < parts.length - 1) return parts.slice(webstormIndex + 1).join("-");
-  const documentsIndex = parts.indexOf("Documents");
-  if (documentsIndex >= 0 && documentsIndex < parts.length - 1) return parts.slice(documentsIndex + 1).join("-");
-  if (parts.length <= 3) return "~";
-  return parts.slice(-2).join("-") || raw;
+  return decodeEncodedPath(match[1]);
 }
 function extractProjectFromKnownToolPath(sourceFile) {
   const normalized = sourceFile.replace(/\\/g, "/");
+  const qoderSessionMatch = normalized.match(/\/\.qoder\/logs\/sessions\/([^/]+)\//);
+  if (qoderSessionMatch) return decodeEncodedPath(qoderSessionMatch[1]);
   if (normalized.includes("/.openclaw/")) {
     const parts = normalized.split("/").filter(Boolean);
     const sessionsIndex = parts.indexOf("sessions");
@@ -134,6 +790,9 @@ function extractProjectFromKnownToolPath(sourceFile) {
   if (normalized.includes("/.codex/") || normalized.includes("/.opencode/")) {
     return extractProjectFromGenericPath(normalized);
   }
+  if (normalized.includes("/.qoder/logs/runs/")) {
+    return "unknown";
+  }
   return null;
 }
 function extractProjectFromGenericPath(sourceFile) {
@@ -144,6 +803,15 @@ function extractProjectFromGenericPath(sourceFile) {
     const candidate = parts[index];
     if (isSkippableDirectoryName(candidate)) continue;
     if (looksMachineGenerated(candidate)) continue;
+    if (isPurelyNumeric(candidate)) {
+      if (index > 0) {
+        const parent = parts[index - 1];
+        if (!isSkippableDirectoryName(parent) && !looksMachineGenerated(parent) && !isPurelyNumeric(parent)) {
+          return `${parent}/${candidate}`;
+        }
+      }
+      continue;
+    }
     return candidate;
   }
   return null;
@@ -152,1462 +820,1782 @@ function isSkippableDirectoryName(name) {
   return GENERIC_DIRECTORY_NAMES.has(name) || TOOL_DIRECTORY_NAMES.has(name);
 }
 function looksMachineGenerated(name) {
-  return /^\d{4}$/.test(name) || /^\d{2}$/.test(name) || /^[0-9a-f]{8,}$/i.test(name) || /^[0-9a-f-]{32,}$/i.test(name);
-}
-
-// src/api/server.ts
-function getDateRangeFilter(range, from, to, prefix = "", weekStart = 1) {
-  const ts = 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 ${ts} >= @start AND ${ts} < @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 ${ts} >= @start`, params: { start: startOfWeek.getTime() } };
-  }
-  if (range === "month") {
-    const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
-    return { where: `AND ${ts} >= @start`, params: { start: startOfMonth.getTime() } };
-  }
-  if (range === "last30") {
-    const start = new Date(today);
-    start.setDate(start.getDate() - 30);
-    return { where: `AND ${ts} >= @start`, params: { start: start.getTime() } };
-  }
-  if (range === "all") {
-    return { where: "", params: {} };
-  }
-  return { where: `AND ${ts} >= @start`, params: { start: today.getTime() } };
-}
-function json(res, data, status = 200) {
-  res.writeHead(status, { "Content-Type": "application/json" });
-  res.end(JSON.stringify(data));
+  return /^\d{4}-\d{2}-\d{2}T/.test(name) || /^[0-9a-f]{8,}$/i.test(name) || /^[0-9a-f-]{32,}$/i.test(name);
 }
-function getToolFilter(tool, prefix = "") {
-  if (!tool) return { where: "", params: {} };
-  const col = prefix ? `${prefix}.tool` : "tool";
-  return { where: `AND ${col} = @tool`, params: { tool } };
-}
-var LOCAL_ONLY_FILTER = "AND source_file NOT LIKE 'synced/%'";
-function getDeviceFilter(device, currentDeviceInstanceId) {
-  if (!currentDeviceInstanceId) {
-    return { where: "", params: {}, useUnion: false, localOnly: false };
-  }
-  if (!device) {
-    return {
-      where: "",
-      params: { currentDeviceId: currentDeviceInstanceId },
-      useUnion: true,
-      localOnly: true
-    };
-  }
-  if (device === currentDeviceInstanceId) {
-    return { where: "", params: {}, useUnion: false, localOnly: true };
-  }
-  return {
-    where: "AND device_instance_id = @deviceId",
-    params: { deviceId: device },
-    useUnion: false,
-    localOnly: false
-  };
+function isPurelyNumeric(name) {
+  return /^\d+$/.test(name);
 }
-function createApiServer(db, options) {
-  const cfg = loadConfig();
-  let weekStart = cfg?.weekStart ?? 1;
-  const server = http.createServer(async (req, res) => {
-    const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
-    if (req.method === "OPTIONS") {
-      res.writeHead(204);
-      res.end();
-      return;
-    }
-    const range = url.searchParams.get("range");
-    const from = url.searchParams.get("from");
-    const to = url.searchParams.get("to");
-    const toolParam = url.searchParams.get("tool");
-    const VALID_TOOLS = ["claude-code", "codex", "openclaw", "opencode", "hermes"];
-    if (toolParam && !VALID_TOOLS.includes(toolParam)) {
-      json(res, { error: { code: "INVALID_PARAM", message: "Invalid tool" } }, 400);
-      return;
-    }
-    try {
-      if (url.pathname === "/api/summary") {
-        if (range && !["day", "week", "month", "last30", "all"].includes(range)) {
-          json(res, { error: { code: "INVALID_PARAM", message: "Invalid range" } }, 400);
-          return;
-        }
-        const device = url.searchParams.get("device");
-        const df = getDeviceFilter(device, options?.currentDeviceInstanceId);
-        const dr = getDateRangeFilter(range, from, to, "", weekStart);
-        const tool = url.searchParams.get("tool");
-        const tf = getToolFilter(tool);
-        let totals;
-        let byToolRows;
-        if (df.useUnion) {
-          const unionSql = `
-            SELECT input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens, cost, ts, session_id
-            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
-            UNION ALL
-            SELECT input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens, cost, ts, session_key AS session_id
-            FROM synced_records WHERE device_instance_id != @currentDeviceId ${dr.where} ${tf.where}
-          `;
-          totals = db.prepare(`
-            SELECT
-              COALESCE(SUM(input_tokens), 0) AS inputTokens,
-              COALESCE(SUM(output_tokens), 0) AS outputTokens,
-              COALESCE(SUM(cache_read_tokens), 0) AS cacheReadTokens,
-              COALESCE(SUM(cache_write_tokens), 0) AS cacheWriteTokens,
-              COALESCE(SUM(thinking_tokens), 0) AS thinkingTokens,
-              COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens), 0) AS totalTokens,
-              COALESCE(SUM(cost), 0) AS totalCost,
-              COUNT(DISTINCT strftime('%Y-%m-%d', ts/1000, 'unixepoch')) AS activeDays,
-              COUNT(DISTINCT session_id) AS totalSessions
-            FROM (${unionSql})
-          `).get({ ...dr.params, ...df.params, ...tf.params });
-          byToolRows = db.prepare(`
-            SELECT tool, SUM(tokens) AS tokens, SUM(cost) AS cost FROM (
-              SELECT tool,
-                     SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS tokens,
-                     SUM(cost) AS cost
-              FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
-              GROUP BY tool
-              UNION ALL
-              SELECT tool,
-                     SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS tokens,
-                     SUM(cost) AS cost
-              FROM synced_records WHERE device_instance_id != @currentDeviceId ${dr.where} ${tf.where}
-              GROUP BY tool
-            ) GROUP BY tool ORDER BY cost DESC
-          `).all({ ...dr.params, ...df.params, ...tf.params });
-        } else if (df.where) {
-          totals = db.prepare(`
-            SELECT
-              COALESCE(SUM(input_tokens), 0) AS inputTokens,
-              COALESCE(SUM(output_tokens), 0) AS outputTokens,
-              COALESCE(SUM(cache_read_tokens), 0) AS cacheReadTokens,
-              COALESCE(SUM(cache_write_tokens), 0) AS cacheWriteTokens,
-              COALESCE(SUM(thinking_tokens), 0) AS thinkingTokens,
-              COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens), 0) AS totalTokens,
-              COALESCE(SUM(cost), 0) AS totalCost,
-              COUNT(DISTINCT strftime('%Y-%m-%d', ts/1000, 'unixepoch')) AS activeDays,
-              COUNT(DISTINCT session_key) AS totalSessions
-            FROM synced_records WHERE 1=1 ${df.where} ${dr.where} ${tf.where}
-          `).get({ ...dr.params, ...df.params, ...tf.params });
-          byToolRows = db.prepare(`
-            SELECT tool,
-                   SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS tokens,
-                   SUM(cost) AS cost
-            FROM synced_records WHERE 1=1 ${df.where} ${dr.where} ${tf.where}
-            GROUP BY tool ORDER BY cost DESC
-          `).all({ ...dr.params, ...df.params, ...tf.params });
-        } else {
-          totals = db.prepare(`
-            SELECT
-              COALESCE(SUM(input_tokens), 0) AS inputTokens,
-              COALESCE(SUM(output_tokens), 0) AS outputTokens,
-              COALESCE(SUM(cache_read_tokens), 0) AS cacheReadTokens,
-              COALESCE(SUM(cache_write_tokens), 0) AS cacheWriteTokens,
-              COALESCE(SUM(thinking_tokens), 0) AS thinkingTokens,
-              COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens), 0) AS totalTokens,
-              COALESCE(SUM(cost), 0) AS totalCost,
-              COUNT(DISTINCT strftime('%Y-%m-%d', ts/1000, 'unixepoch')) AS activeDays,
-              COUNT(DISTINCT session_id) AS totalSessions
-            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
-          `).get({ ...dr.params, ...tf.params });
-          byToolRows = db.prepare(`
-            SELECT tool,
-                   SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS tokens,
-                   SUM(cost) AS cost
-            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
-            GROUP BY tool ORDER BY cost DESC
-          `).all({ ...dr.params, ...tf.params });
-        }
-        const byTool = {};
-        for (const row of byToolRows) {
-          byTool[row.tool] = { tokens: row.tokens, cost: row.cost };
-        }
-        const drJoin = getDateRangeFilter(range, from, to, "r", weekStart);
-        const dfJoin = df.where ? df.where.replace(/device_instance_id/g, "r.device_instance_id") : "";
-        const tfJoin = getToolFilter(tool, "r");
-        const topToolCalls = db.prepare(`
-          SELECT tc.name, COUNT(*) AS count
-          FROM tool_calls tc
-          JOIN records r ON r.id = tc.record_id
-          WHERE 1=1 ${dfJoin} ${drJoin.where} ${tfJoin.where}
-          GROUP BY tc.name ORDER BY count DESC LIMIT 10
-        `).all({ ...drJoin.params, ...df.params, ...tfJoin.params });
-        json(res, {
-          inputTokens: totals.inputTokens,
-          outputTokens: totals.outputTokens,
-          cacheReadTokens: totals.cacheReadTokens,
-          cacheWriteTokens: totals.cacheWriteTokens,
-          thinkingTokens: totals.thinkingTokens,
-          totalTokens: totals.totalTokens,
-          totalCost: totals.totalCost,
-          activeDays: totals.activeDays,
-          totalSessions: totals.totalSessions,
-          byTool,
-          topToolCalls
-        });
-        return;
-      }
-      if (url.pathname === "/api/tokens") {
-        const dr = getDateRangeFilter(range, from, to, "", weekStart);
-        const device = url.searchParams.get("device");
-        const df = getDeviceFilter(device, options?.currentDeviceInstanceId);
-        const tool = url.searchParams.get("tool");
-        const tf = getToolFilter(tool);
-        let sql;
-        let params;
-        if (df.useUnion) {
-          sql = `
-            SELECT strftime('%Y-%m-%d', ts/1000, 'unixepoch') AS date,
-                   SUM(input_tokens) AS inputTokens,
-                   SUM(output_tokens) AS outputTokens,
-                   SUM(cache_read_tokens) AS cacheReadTokens,
-                   SUM(cache_write_tokens) AS cacheWriteTokens,
-                   SUM(thinking_tokens) AS thinkingTokens
-            FROM (
-              SELECT input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens, ts FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
-              UNION ALL
-              SELECT input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens, ts FROM synced_records WHERE device_instance_id != @currentDeviceId ${dr.where} ${tf.where}
-            )
-            GROUP BY date ORDER BY date`;
-          params = { ...dr.params, currentDeviceId: df.params.currentDeviceId, ...tf.params };
-        } else if (device && device !== options?.currentDeviceInstanceId) {
-          sql = `
-            SELECT strftime('%Y-%m-%d', ts/1000, 'unixepoch') AS date,
-                   SUM(input_tokens) AS inputTokens,
-                   SUM(output_tokens) AS outputTokens,
-                   SUM(cache_read_tokens) AS cacheReadTokens,
-                   SUM(cache_write_tokens) AS cacheWriteTokens,
-                   SUM(thinking_tokens) AS thinkingTokens
-            FROM synced_records WHERE 1=1 ${df.where} ${dr.where} ${tf.where}
-            GROUP BY date ORDER BY date`;
-          params = { ...df.params, ...dr.params, ...tf.params };
-        } else {
-          sql = `
-            SELECT strftime('%Y-%m-%d', ts/1000, 'unixepoch') AS date,
-                   SUM(input_tokens) AS inputTokens,
-                   SUM(output_tokens) AS outputTokens,
-                   SUM(cache_read_tokens) AS cacheReadTokens,
-                   SUM(cache_write_tokens) AS cacheWriteTokens,
-                   SUM(thinking_tokens) AS thinkingTokens
-            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
-            GROUP BY date ORDER BY date`;
-          params = { ...dr.params, ...tf.params };
-        }
-        const rows = db.prepare(sql).all(params);
-        json(res, { data: rows });
-        return;
-      }
-      if (url.pathname === "/api/cost") {
-        const dr = getDateRangeFilter(range, from, to, "", weekStart);
-        const device = url.searchParams.get("device");
-        const df = getDeviceFilter(device, options?.currentDeviceInstanceId);
-        const tool = url.searchParams.get("tool");
-        const tf = getToolFilter(tool);
-        let daily;
-        let byToolRows;
-        let byModelRows;
-        if (df.useUnion) {
-          daily = db.prepare(`
-            SELECT strftime('%Y-%m-%d', ts/1000, 'unixepoch') AS date,
-                   SUM(cost) AS cost
-            FROM (
-              SELECT cost, ts FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
-              UNION ALL
-              SELECT cost, ts FROM synced_records WHERE device_instance_id != @currentDeviceId ${dr.where} ${tf.where}
-            )
-            GROUP BY date ORDER BY date
-          `).all({ ...dr.params, currentDeviceId: df.params.currentDeviceId, ...tf.params });
-          byToolRows = db.prepare(`
-            SELECT tool, SUM(cost) AS cost FROM (
-              SELECT tool, SUM(cost) AS cost FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where} GROUP BY tool
-              UNION ALL
-              SELECT tool, SUM(cost) AS cost FROM synced_records WHERE device_instance_id != @currentDeviceId ${dr.where} ${tf.where} GROUP BY tool
-            ) GROUP BY tool ORDER BY cost DESC
-          `).all({ ...dr.params, currentDeviceId: df.params.currentDeviceId, ...tf.params });
-          byModelRows = db.prepare(`
-            SELECT model, SUM(cost) AS cost FROM (
-              SELECT model, SUM(cost) AS cost FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where} GROUP BY model
-              UNION ALL
-              SELECT model, SUM(cost) AS cost FROM synced_records WHERE device_instance_id != @currentDeviceId ${dr.where} ${tf.where} GROUP BY model
-            ) GROUP BY model ORDER BY cost DESC
-          `).all({ ...dr.params, currentDeviceId: df.params.currentDeviceId, ...tf.params });
-        } else if (device && device !== options?.currentDeviceInstanceId) {
-          daily = db.prepare(`
-            SELECT strftime('%Y-%m-%d', ts/1000, 'unixepoch') AS date,
-                   SUM(cost) AS cost
-            FROM synced_records WHERE 1=1 ${df.where} ${dr.where} ${tf.where}
-            GROUP BY date ORDER BY date
-          `).all({ ...df.params, ...dr.params, ...tf.params });
-          byToolRows = db.prepare(`
-            SELECT tool, SUM(cost) AS cost
-            FROM synced_records WHERE 1=1 ${df.where} ${dr.where} ${tf.where}
-            GROUP BY tool ORDER BY cost DESC
-          `).all({ ...df.params, ...dr.params, ...tf.params });
-          byModelRows = db.prepare(`
-            SELECT model, SUM(cost) AS cost
-            FROM synced_records WHERE 1=1 ${df.where} ${dr.where} ${tf.where}
-            GROUP BY model ORDER BY cost DESC
-          `).all({ ...df.params, ...dr.params, ...tf.params });
-        } else {
-          daily = db.prepare(`
-            SELECT strftime('%Y-%m-%d', ts/1000, 'unixepoch') AS date,
-                   SUM(cost) AS cost
-            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
-            GROUP BY date ORDER BY date
-          `).all({ ...dr.params, ...tf.params });
-          byToolRows = db.prepare(`
-            SELECT tool, SUM(cost) AS cost
-            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
-            GROUP BY tool ORDER BY cost DESC
-          `).all({ ...dr.params, ...tf.params });
-          byModelRows = db.prepare(`
-            SELECT model, SUM(cost) AS cost
-            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
-            GROUP BY model ORDER BY cost DESC
-          `).all({ ...dr.params, ...tf.params });
-        }
-        const byTool = {};
-        for (const r of byToolRows) byTool[r.tool] = r.cost;
-        const byModel = {};
-        for (const r of byModelRows) byModel[r.model] = r.cost;
-        json(res, { data: daily, byTool, byModel });
-        return;
-      }
-      if (url.pathname === "/api/models") {
-        const dr = getDateRangeFilter(range, from, to, "", weekStart);
-        const device = url.searchParams.get("device");
-        const df = getDeviceFilter(device, options?.currentDeviceInstanceId);
-        const tool = url.searchParams.get("tool");
-        const tf = getToolFilter(tool);
-        let total;
-        let rows;
-        if (df.useUnion) {
-          const unionSql = `
-            SELECT model, provider, COUNT(*) AS callCount,
-                   SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS totalTokens
-            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
-            GROUP BY model, provider
-            UNION ALL
-            SELECT model, provider, COUNT(*) AS callCount,
-                   SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS totalTokens
-            FROM synced_records WHERE device_instance_id != @currentDeviceId ${dr.where} ${tf.where}
-            GROUP BY model, provider
-          `;
-          const mergedRows = db.prepare(`
-            SELECT model, provider, SUM(callCount) AS callCount, SUM(totalTokens) AS totalTokens
-            FROM (${unionSql})
-            GROUP BY model, provider ORDER BY callCount DESC
-          `).all({ ...dr.params, ...df.params, ...tf.params });
-          total = mergedRows.reduce((s, r) => s + r.callCount, 0) || 1;
-          rows = mergedRows;
-        } else if (device && device !== options?.currentDeviceInstanceId) {
-          rows = db.prepare(`
-            SELECT model, provider,
-                   COUNT(*) AS callCount,
-                   SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS totalTokens
-            FROM synced_records WHERE 1=1 ${df.where} ${dr.where} ${tf.where}
-            GROUP BY model, provider ORDER BY callCount DESC
-          `).all({ ...df.params, ...dr.params, ...tf.params });
-          total = rows.reduce((s, r) => s + r.callCount, 0) || 1;
-        } else {
-          rows = db.prepare(`
-            SELECT model, provider,
-                   COUNT(*) AS callCount,
-                   SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS totalTokens
-            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
-            GROUP BY model, provider ORDER BY callCount DESC
-          `).all({ ...dr.params, ...tf.params });
-          total = rows.reduce((s, r) => s + r.callCount, 0) || 1;
-        }
-        const models = rows.map((r) => ({
-          model: r.model,
-          provider: r.provider,
-          callCount: r.callCount,
-          totalTokens: r.totalTokens,
-          percentage: Math.round(r.callCount / total * 1e3) / 10
-        }));
-        json(res, { models });
-        return;
-      }
-      if (url.pathname === "/api/tool-calls") {
-        const device = url.searchParams.get("device");
-        if (device && device !== options?.currentDeviceInstanceId) {
-          json(res, { toolCalls: [] });
-          return;
-        }
-        const dr = getDateRangeFilter(range, from, to, "r", weekStart);
-        const tool = url.searchParams.get("tool");
-        const tf = getToolFilter(tool, "r");
-        const totalRow = db.prepare(`
-          SELECT COUNT(*) AS total FROM tool_calls tc
-          JOIN records r ON r.id = tc.record_id
-          WHERE 1=1 ${dr.where} ${tf.where}
-        `).get({ ...dr.params, ...tf.params });
-        const total = totalRow.total || 1;
-        const rows = db.prepare(`
-          SELECT tc.name, COUNT(*) AS count
-          FROM tool_calls tc
-          JOIN records r ON r.id = tc.record_id
-          WHERE 1=1 ${dr.where} ${tf.where}
-          GROUP BY tc.name ORDER BY count DESC
-        `).all({ ...dr.params, ...tf.params });
-        const toolCalls = rows.map((r) => ({
-          name: r.name,
-          count: r.count,
-          percentage: Math.round(r.count / total * 1e3) / 10
-        }));
-        json(res, { toolCalls });
-        return;
-      }
-      if (url.pathname === "/api/sessions") {
-        const page = Math.max(1, parseInt(url.searchParams.get("page") || "1", 10));
-        const pageSize = Math.min(100, Math.max(1, parseInt(url.searchParams.get("pageSize") || "50", 10)));
-        const dr = getDateRangeFilter(range, from, to, "", weekStart);
-        const device = url.searchParams.get("device");
-        const df = getDeviceFilter(device, options?.currentDeviceInstanceId);
-        const tool = url.searchParams.get("tool");
-        if (device && !df.localOnly && !df.useUnion) {
-          json(res, {
-            sessions: [],
-            total: 0,
-            page,
-            pageSize
-          });
-          return;
-        }
-        const tf = getToolFilter(tool);
-        const params = { ...dr.params, ...tf.params };
-        const totalRow = db.prepare(`
-          SELECT COUNT(DISTINCT session_id) AS total
-          FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
-        `).get(params);
-        const sessions = db.prepare(`
-          SELECT session_id AS sessionId,
-                 tool,
-                 model,
-                 MIN(ts) AS ts,
-                 SUM(input_tokens) AS inputTokens,
-                 SUM(output_tokens) AS outputTokens,
-                 SUM(cache_read_tokens) AS cacheReadTokens,
-                 SUM(cache_write_tokens) AS cacheWriteTokens,
-                 SUM(cost) AS cost
-          FROM records
-          WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
-          GROUP BY session_id
-          ORDER BY ts DESC
-          LIMIT @limit OFFSET @offset
-        `).all({ ...params, limit: pageSize, offset: (page - 1) * pageSize });
-        json(res, {
-          sessions,
-          total: totalRow.total,
-          page,
-          pageSize
-        });
-        return;
+
+// src/commands/parse.ts
+import Database from "better-sqlite3";
+import { readFileSync as readFileSync4, readdirSync, statSync, existsSync as existsSync4, openSync, readSync, closeSync } from "fs";
+import { join as join3, extname } from "path";
+import { homedir as homedir2, hostname, platform } 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) {
+  const rows = db.prepare(
+    "SELECT * FROM records WHERE synced_at IS NULL OR updated_at > synced_at"
+  ).all();
+  return rows.map(mapRowToRecord);
+}
+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/tool-calls.ts
+function insertToolCall(db, tc) {
+  db.prepare(`
+    INSERT OR REPLACE INTO tool_calls (id, record_id, tool, name, ts, call_index)
+    VALUES (@id, @recordId, @tool, @name, @ts, @callIndex)
+  `).run({
+    id: tc.id,
+    recordId: tc.recordId ?? null,
+    tool: tc.recordId ? null : tc.tool,
+    name: tc.name,
+    ts: tc.ts,
+    callIndex: tc.callIndex
+  });
+}
+function getToolCallStats(db) {
+  return db.prepare(`
+    SELECT name, COUNT(*) as count
+    FROM tool_calls
+    GROUP BY name
+    ORDER BY count DESC
+  `).all();
+}
+
+// src/init.ts
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { randomUUID } from "crypto";
+function getState(aiusageDir) {
+  const statePath = join2(aiusageDir, "state.json");
+  if (!existsSync2(statePath)) return null;
+  try {
+    const content = readFileSync2(statePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function setState(aiusageDir, updates) {
+  const statePath = join2(aiusageDir, "state.json");
+  const current = getState(aiusageDir) ?? {
+    deviceInstanceId: randomUUID(),
+    lastSyncStatus: "ok"
+  };
+  const updated = { ...current, ...updates };
+  writeFileSync2(statePath, JSON.stringify(updated, null, 2), "utf-8");
+}
+
+// src/watermark.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3 } from "fs";
+function defaultFileData() {
+  return {
+    "claude-code": {},
+    "codex": {},
+    "openclaw": {},
+    "opencode": {},
+    "hermes": {},
+    "qoder": {}
+  };
+}
+var WatermarkManager = class {
+  data;
+  path;
+  constructor(path3) {
+    this.path = path3;
+    this.data = this.load();
+  }
+  load() {
+    if (!existsSync3(this.path)) {
+      return { files: defaultFileData() };
+    }
+    try {
+      const content = readFileSync3(this.path, "utf-8");
+      const parsed = JSON.parse(content);
+      if (parsed && typeof parsed === "object" && !("files" in parsed)) {
+        return { files: { ...defaultFileData(), ...parsed } };
       }
-      if (url.pathname === "/api/projects") {
-        const dr = getDateRangeFilter(range, from, to, "", weekStart);
-        const device = url.searchParams.get("device");
-        const df = getDeviceFilter(device, options?.currentDeviceInstanceId);
-        const tool = url.searchParams.get("tool");
-        const tf = getToolFilter(tool);
-        if (df.where && !df.useUnion) {
-          json(res, { projects: [] });
-          return;
-        }
-        const rows = db.prepare(`
-          SELECT source_file,
-                 COUNT(*) AS sessionCount,
-                 SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS totalTokens,
-                 SUM(cost) AS cost
-          FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
-          GROUP BY source_file ORDER BY totalTokens DESC
-        `).all({ ...dr.params, ...tf.params });
-        const projectMap = {};
-        for (const row of rows) {
-          const project = extractProject(row.source_file);
-          if (!projectMap[project]) projectMap[project] = { sessions: 0, tokens: 0, cost: 0 };
-          projectMap[project].sessions += row.sessionCount;
-          projectMap[project].tokens += row.totalTokens;
-          projectMap[project].cost += row.cost;
+      return { files: { ...defaultFileData(), ...parsed.files ?? {} }, opencode: parsed.opencode ?? null, hermes: parsed.hermes ?? null, qoder: parsed.qoder ?? null };
+    } catch {
+      return { files: defaultFileData() };
+    }
+  }
+  save() {
+    writeFileSync3(this.path, JSON.stringify(this.data, null, 2), "utf-8");
+  }
+  getEntry(tool, filePath) {
+    return this.data.files[tool]?.[filePath] ?? null;
+  }
+  setEntry(tool, filePath, entry) {
+    if (!this.data.files[tool]) {
+      this.data.files[tool] = {};
+    }
+    this.data.files[tool][filePath] = entry;
+  }
+  cleanup(existingFiles) {
+    const existingSet = new Set(existingFiles);
+    for (const tool of Object.keys(this.data.files)) {
+      for (const filePath of Object.keys(this.data.files[tool])) {
+        if (!existingSet.has(filePath)) {
+          delete this.data.files[tool][filePath];
         }
-        const totalTokens = Object.values(projectMap).reduce((s, p) => s + p.tokens, 0) || 1;
-        const projects = Object.entries(projectMap).map(([name, data]) => ({
-          name,
-          sessions: data.sessions,
-          tokens: data.tokens,
-          cost: data.cost,
-          percentage: Math.round(data.tokens / totalTokens * 1e3) / 10
-        })).sort((a, b) => b.tokens - a.tokens);
-        json(res, { projects });
-        return;
       }
-      if (url.pathname === "/api/pricing") {
-        if (req.method === "GET") {
-          const table = getPriceTable();
-          const overrides = getUserOverrides();
-          const dbModels = db.prepare("SELECT DISTINCT model FROM records ORDER BY model").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,
-              isDefault,
-              isOverride,
-              matchedBy
-            };
-          });
-          json(res, { models, overrides });
-          return;
-        }
-        if (req.method === "PUT") {
-          let body = "";
-          for await (const chunk of req) body += chunk;
-          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,
-              thinking: data.thinking
-            };
-            setPriceOverride(data.model, entry);
-            const cfg2 = loadConfig() ?? {};
-            cfg2.priceOverrides = { ...cfg2.priceOverrides, [data.model]: entry };
-            saveConfig(cfg2);
-            json(res, { ok: true });
-          } catch {
-            json(res, { error: { code: "INVALID_JSON", message: "Invalid JSON body" } }, 400);
-          }
-          return;
-        }
-        if (req.method === "DELETE") {
-          const model = url.searchParams.get("model");
-          if (!model) {
-            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);
-          }
-          json(res, { ok: true });
-          return;
-        }
+    }
+  }
+  getOpenCodeCursor() {
+    return this.data.opencode ?? null;
+  }
+  setOpenCodeCursor(cursor) {
+    this.data.opencode = cursor;
+  }
+  getHermesCursor() {
+    return this.data.hermes ?? null;
+  }
+  setHermesCursor(cursor) {
+    this.data.hermes = cursor;
+  }
+  getQoderCursor() {
+    return this.data.qoder ?? null;
+  }
+  setQoderCursor(cursor) {
+    this.data.qoder = cursor;
+  }
+};
+
+// src/commands/parse-opencode.ts
+function runParseOpenCode(db, options) {
+  const { dbPath, device, deviceInstanceId, platform: platform4, now, cursor, exchangeRate } = options;
+  const records = [];
+  const toolCalls = [];
+  const errors = [];
+  let lastCursor = null;
+  const messages = db.prepare(
+    `SELECT m.id, m.session_id, m.time_created, m.data
+       FROM message m
+       WHERE m.time_created > ? OR (m.time_created = ? AND m.id > ?)
+       ORDER BY m.time_created, m.id`
+  ).all(
+    cursor?.lastMessageCreatedAt ?? 0,
+    cursor?.lastMessageCreatedAt ?? 0,
+    cursor?.lastMessageId ?? ""
+  );
+  const partsStmt = db.prepare(
+    `SELECT id, message_id, session_id, time_created, data
+     FROM part
+     WHERE message_id = ?
+     ORDER BY time_created, id`
+  );
+  for (const message of messages) {
+    lastCursor = {
+      lastMessageCreatedAt: message.time_created,
+      lastMessageId: message.id
+    };
+    let parsed;
+    try {
+      parsed = JSON.parse(message.data);
+    } catch (e) {
+      errors.push(`message ${message.id}: invalid JSON: ${e instanceof Error ? e.message : e}`);
+      continue;
+    }
+    if (parsed.role !== "assistant" || !parsed.tokens) continue;
+    const inputTokens = parsed.tokens.input ?? 0;
+    const outputTokens = parsed.tokens.output ?? 0;
+    const reasoningTokens = parsed.tokens.reasoning ?? 0;
+    const cacheReadTokens = parsed.tokens.cache?.read ?? 0;
+    const cacheWriteTokens = parsed.tokens.cache?.write ?? 0;
+    if (inputTokens === 0 && outputTokens === 0 && reasoningTokens === 0 && cacheReadTokens === 0 && cacheWriteTokens === 0) continue;
+    const model = parsed.modelID ?? "unknown";
+    const provider = parsed.providerID ?? inferProvider(model);
+    const ts = parsed.time?.created ?? message.time_created;
+    const recordId = generateRecordId(deviceInstanceId, dbPath + ":" + message.id, message.time_created);
+    const tokenArgs = { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, thinkingTokens: reasoningTokens };
+    const calculatedCost = model !== "unknown" ? calculateCost(model, tokenArgs, exchangeRate) : 0;
+    const logCostValid = parsed.cost != null && parsed.cost > 0;
+    const cost = logCostValid ? parsed.cost : calculatedCost;
+    const costSource = logCostValid ? "log" : calculatedCost > 0 ? "pricing" : "unknown";
+    const record = {
+      id: recordId,
+      ts,
+      ingestedAt: now,
+      updatedAt: now,
+      lineOffset: 0,
+      // DB-sourced records have no byte offset; use 0 as sentinel
+      tool: "opencode",
+      model,
+      provider,
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      thinkingTokens: reasoningTokens,
+      cost,
+      costSource,
+      sessionId: message.session_id,
+      sourceFile: dbPath,
+      device,
+      deviceInstanceId,
+      platform: platform4
+    };
+    records.push(record);
+    const parts = partsStmt.all(message.id);
+    let callIndex = 0;
+    for (const part of parts) {
+      let partParsed;
+      try {
+        partParsed = JSON.parse(part.data);
+      } catch (e) {
+        errors.push(`message ${message.id} part ${part.id}: invalid JSON: ${e instanceof Error ? e.message : e}`);
+        continue;
       }
-      if (url.pathname === "/api/pricing/recalc" && req.method === "POST") {
-        const { resolvePrice: resolvePrice2 } = await import("./dist-4I33E46P.js");
-        const BATCH_SIZE2 = 1e3;
-        let updated = 0;
-        let lastId = "";
-        while (true) {
-          const records = db.prepare(
-            "SELECT id, model, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens FROM records WHERE id > ? ORDER BY id LIMIT ?"
-          ).all(lastId, BATCH_SIZE2);
-          if (records.length === 0) break;
-          const updateStmt = db.prepare("UPDATE records SET cost = ?, cost_source = ? WHERE id = ?");
-          const tx = db.transaction((batch) => {
-            for (const r of batch) {
-              const price = resolvePrice2(r.model);
-              if (!price) continue;
-              const cost = r.input_tokens / 1e6 * price.input + r.output_tokens / 1e6 * price.output + r.cache_read_tokens / 1e6 * (price.cacheRead ?? 0) + r.cache_write_tokens / 1e6 * (price.cacheWrite ?? 0) + r.thinking_tokens / 1e6 * (price.thinking ?? price.output);
-              updateStmt.run(cost, "pricing", r.id);
-              updated++;
-            }
-          });
-          tx(records);
-          lastId = records[records.length - 1].id;
-        }
-        json(res, { updated });
-        return;
+      if (partParsed.type === "tool" && partParsed.tool) {
+        toolCalls.push({
+          id: generateToolCallId(recordId, partParsed.tool, part.time_created, callIndex),
+          recordId,
+          name: partParsed.tool,
+          ts: part.time_created,
+          callIndex
+        });
+        callIndex++;
       }
-      if (url.pathname === "/api/sync") {
-        if (req.method === "POST") {
-          if (!options?.onSyncStart) {
-            json(res, { error: { code: "NOT_AVAILABLE", message: "Sync not configured" } }, 501);
-            return;
-          }
-          const result = options.onSyncStart();
-          json(res, result, result.accepted ? 202 : 200);
-          return;
+    }
+  }
+  return { records, toolCalls, nextCursor: records.length > 0 ? lastCursor : null, errors };
+}
+
+// src/commands/parse-hermes.ts
+function runParseHermes(db, options) {
+  const { dbPath, device, deviceInstanceId, platform: platform4, now, cursor, exchangeRate } = options;
+  const records = [];
+  const toolCalls = [];
+  const errors = [];
+  let lastCursor = null;
+  const sessions = db.prepare(
+    `SELECT id, model, billing_provider, started_at, ended_at,
+              input_tokens, output_tokens, cache_read_tokens, cache_write_tokens,
+              reasoning_tokens, estimated_cost_usd, actual_cost_usd,
+              COALESCE(ended_at, started_at) AS session_ts
+       FROM sessions
+       WHERE (ended_at IS NOT NULL OR input_tokens > 0 OR output_tokens > 0)
+         AND (COALESCE(ended_at, started_at) > ? OR (COALESCE(ended_at, started_at) = ? AND id > ?))
+       ORDER BY COALESCE(ended_at, started_at), id`
+  ).all(
+    cursor?.lastEndedAt ?? 0,
+    cursor?.lastEndedAt ?? 0,
+    cursor?.lastId ?? ""
+  );
+  const toolCallsStmt = db.prepare(
+    `SELECT id, session_id, tool_calls, timestamp
+     FROM messages
+     WHERE session_id = ? AND tool_calls IS NOT NULL
+     ORDER BY timestamp, id`
+  );
+  for (const session of sessions) {
+    lastCursor = { lastEndedAt: session.session_ts, lastId: session.id };
+    const model = session.model ?? "unknown";
+    const ts = Math.round(session.started_at * 1e3);
+    const rawProvider = session.billing_provider;
+    const provider = rawProvider && rawProvider !== "custom" ? rawProvider : inferProvider(model);
+    const inputTokens = session.input_tokens;
+    const outputTokens = session.output_tokens;
+    const cacheReadTokens = session.cache_read_tokens;
+    const cacheWriteTokens = session.cache_write_tokens;
+    const thinkingTokens = session.reasoning_tokens;
+    const tokenArgs = { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, thinkingTokens };
+    let cost;
+    let costSource;
+    if (session.actual_cost_usd != null && session.actual_cost_usd > 0) {
+      cost = session.actual_cost_usd;
+      costSource = "log";
+    } else if (session.estimated_cost_usd != null && session.estimated_cost_usd > 0) {
+      cost = session.estimated_cost_usd;
+      costSource = "log";
+    } else if (model !== "unknown") {
+      cost = calculateCost(model, tokenArgs, exchangeRate);
+      costSource = cost > 0 ? "pricing" : "unknown";
+    } else {
+      cost = 0;
+      costSource = "unknown";
+    }
+    const recordId = generateRecordId(deviceInstanceId, dbPath + ":" + session.id, ts);
+    const record = {
+      id: recordId,
+      ts,
+      ingestedAt: now,
+      updatedAt: now,
+      lineOffset: 0,
+      tool: "hermes",
+      model,
+      provider,
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      thinkingTokens,
+      cost,
+      costSource,
+      sessionId: session.id,
+      sourceFile: dbPath,
+      device,
+      deviceInstanceId,
+      platform: platform4
+    };
+    records.push(record);
+    const messages = toolCallsStmt.all(session.id);
+    let callIndex = 0;
+    for (const message of messages) {
+      let toolCallList;
+      try {
+        const parsed = JSON.parse(message.tool_calls);
+        if (!Array.isArray(parsed)) {
+          errors.push(`session ${session.id} message ${message.id}: tool_calls payload is not an array`);
+          continue;
         }
-        const status = options?.getSyncStatus?.() ?? null;
-        json(res, { status });
-        return;
+        toolCallList = parsed;
+      } catch (e) {
+        errors.push(`session ${session.id} message ${message.id}: invalid tool_calls JSON: ${e instanceof Error ? e.message : e}`);
+        continue;
       }
-      if (url.pathname === "/api/refresh") {
-        if (!options?.onRefresh) {
-          json(res, { error: { code: "NOT_AVAILABLE", message: "Refresh not available" } }, 501);
-          return;
-        }
-        const result = await options.onRefresh();
-        json(res, result);
-        return;
+      for (const tc of toolCallList) {
+        const name = tc.function?.name;
+        if (!name) continue;
+        toolCalls.push({
+          id: generateToolCallId(recordId, name, Math.round(message.timestamp * 1e3), callIndex),
+          recordId,
+          name,
+          ts: Math.round(message.timestamp * 1e3),
+          callIndex
+        });
+        callIndex++;
       }
-      if (url.pathname === "/api/devices") {
-        let getDisplayName2 = function(device, deviceInstanceId) {
-          if (deviceInstanceId === currentId) return currentDeviceAlias;
-          if (device && device !== "unknown" && !/^[0-9a-f]{8}$/.test(device)) return device;
-          if (/^[0-9a-f]{8}-/.test(deviceInstanceId)) return deviceInstanceId.slice(0, 8);
-          if (device && device !== "unknown") return device;
-          return "Unknown Device";
-        }, getPlatformLabel2 = function(p) {
-          if (p === "win32") return "Windows";
-          if (p === "darwin") return "macOS";
-          if (p === "linux") return "Linux";
-          return "";
-        }, inferPlatform2 = function(device, deviceInstanceId) {
-          const name = (device || "").toLowerCase();
-          const id = (deviceInstanceId || "").toLowerCase();
-          if (/^(desktop|laptop)-/.test(name)) return "Windows";
-          if (name.endsWith(".local") || /macbook|imac|mac\s*mini|mac\s*pro|mac\s*studio/.test(name)) return "macOS";
-          if (/^(ubuntu|debian|centos|fedora|arch|linux|server|node|prod|dev|staging)/.test(name)) return "Linux";
-          return "";
-        };
-        var getDisplayName = getDisplayName2, getPlatformLabel = getPlatformLabel2, inferPlatform = inferPlatform2;
-        const currentId = options?.currentDeviceInstanceId;
-        if (!currentId) {
-          json(res, { currentDeviceInstanceId: null, devices: [] });
-          return;
-        }
-        const config = loadConfig();
-        const currentDeviceAlias = config?.device || hostname();
-        const localRows = db.prepare(`
-          SELECT device, device_instance_id AS deviceInstanceId, COUNT(*) AS recordCount
-          FROM records
-          WHERE device_instance_id = @currentId AND source_file NOT LIKE 'synced/%'
-          GROUP BY device_instance_id
-        `).all({ currentId });
-        const syncedRows = db.prepare(`
-          SELECT device, device_instance_id AS deviceInstanceId, platform, COUNT(*) AS recordCount
-          FROM synced_records
-          WHERE device_instance_id != @currentId
-          GROUP BY device_instance_id
-        `).all({ currentId });
-        const currentPlatform = config?.platform || platform();
-        const deviceMap = /* @__PURE__ */ new Map();
-        for (const row of localRows) {
-          const displayName = getDisplayName2(row.device, row.deviceInstanceId);
-          deviceMap.set(row.deviceInstanceId, { device: row.device, deviceInstanceId: row.deviceInstanceId, displayName, platform: getPlatformLabel2(currentPlatform), recordCount: row.recordCount });
+    }
+  }
+  return { records, toolCalls, nextCursor: lastCursor, errors };
+}
+
+// src/commands/parse-qoder.ts
+function parseModelKey(recordExtra) {
+  if (!recordExtra) return "qoder-auto";
+  try {
+    const parsed = JSON.parse(recordExtra);
+    const key = parsed?.modelConfig?.key?.trim() ?? "";
+    const normalized = normalizeQoderModel(key);
+    return normalized === "unknown" ? "qoder-auto" : normalized;
+  } catch {
+    return "qoder-auto";
+  }
+}
+function runParseQoder(db, options) {
+  const { dbPath, device, deviceInstanceId, platform: platform4, now, cursor, exchangeRate } = options;
+  const records = [];
+  const toolCalls = [];
+  const errors = [];
+  let lastCursor = null;
+  const messages = db.prepare(
+    `SELECT m.id, m.session_id, m.gmt_create, m.token_info,
+              r.extra AS record_extra
+       FROM chat_message m
+       LEFT JOIN chat_record r ON m.request_id = r.request_id
+       WHERE m.role = 'assistant'
+         AND length(m.token_info) > 2
+         AND (m.gmt_create > ? OR (m.gmt_create = ? AND m.id > ?))
+       ORDER BY m.gmt_create, m.id`
+  ).all(
+    cursor?.lastGmtCreate ?? 0,
+    cursor?.lastGmtCreate ?? 0,
+    cursor?.lastId ?? ""
+  );
+  for (const row of messages) {
+    lastCursor = { lastGmtCreate: row.gmt_create, lastId: row.id };
+    let tokenInfo;
+    try {
+      tokenInfo = JSON.parse(row.token_info);
+    } catch (e) {
+      errors.push(`message ${row.id}: invalid token_info JSON: ${e instanceof Error ? e.message : e}`);
+      continue;
+    }
+    const cacheReadTokens = tokenInfo.cached_tokens ?? 0;
+    const inputTokens = Math.max(0, (tokenInfo.prompt_tokens ?? 0) - cacheReadTokens);
+    const outputTokens = tokenInfo.completion_tokens ?? 0;
+    if (inputTokens === 0 && outputTokens === 0 && cacheReadTokens === 0) continue;
+    const model = parseModelKey(row.record_extra);
+    const provider = inferProvider(model);
+    const ts = row.gmt_create;
+    const tokenArgs = { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens: 0, thinkingTokens: 0 };
+    const calculatedCost = calculateCost(model, tokenArgs, exchangeRate);
+    const cost = calculatedCost;
+    const costSource = calculatedCost > 0 ? "pricing" : "unknown";
+    const recordId = generateRecordId(deviceInstanceId, dbPath + ":" + row.id, ts);
+    records.push({
+      id: recordId,
+      ts,
+      ingestedAt: now,
+      updatedAt: now,
+      lineOffset: 0,
+      tool: "qoder",
+      model,
+      provider,
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens: 0,
+      thinkingTokens: 0,
+      cost,
+      costSource,
+      sessionId: row.session_id,
+      sourceFile: dbPath,
+      device,
+      deviceInstanceId,
+      platform: platform4
+    });
+  }
+  return { records, toolCalls, nextCursor: lastCursor, errors };
+}
+
+// src/commands/parse.ts
+function unique(paths) {
+  return [...new Set(paths)];
+}
+function findJsonlFiles(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(...findJsonlFiles(fullPath));
+      } else if (entry.isFile() && extname(entry.name) === ".jsonl") {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function findQoderSessionSegmentFiles(dir) {
+  return findJsonlFiles(dir).filter((filePath) => {
+    const parts = filePath.replace(/\\/g, "/").split("/").filter(Boolean);
+    const sessionsIndex = parts.lastIndexOf("sessions");
+    const segmentsIndex = parts.lastIndexOf("segments");
+    return sessionsIndex >= 0 && segmentsIndex > sessionsIndex && segmentsIndex === parts.length - 2;
+  });
+}
+function windowsUserHomesFromWsl() {
+  const homes = [];
+  if (!existsSync4("/mnt")) return homes;
+  try {
+    const drives = readdirSync("/mnt", { withFileTypes: true });
+    for (const drive of drives) {
+      if (!drive.isDirectory() || !/^[a-z]$/i.test(drive.name)) continue;
+      const usersDir = join3("/mnt", drive.name, "Users");
+      if (!existsSync4(usersDir)) continue;
+      try {
+        const users = readdirSync(usersDir, { withFileTypes: true });
+        for (const user of users) {
+          if (!user.isDirectory()) continue;
+          if (["All Users", "Default", "Default User", "Public"].includes(user.name)) continue;
+          homes.push(join3(usersDir, user.name));
         }
-        for (const row of syncedRows) {
-          const displayName = getDisplayName2(row.device, row.deviceInstanceId);
-          const platformLabel = getPlatformLabel2(row.platform) || inferPlatform2(row.device, row.deviceInstanceId);
-          const existing = deviceMap.get(row.deviceInstanceId);
-          if (existing) {
-            existing.recordCount += row.recordCount;
-          } else {
-            deviceMap.set(row.deviceInstanceId, { device: row.device, deviceInstanceId: row.deviceInstanceId, displayName, platform: platformLabel, recordCount: row.recordCount });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return homes;
+}
+function defaultQoderSessionDirs(home) {
+  const windowsHomes = [
+    process.env.USERPROFILE,
+    ...windowsUserHomesFromWsl()
+  ].filter((value) => !!value);
+  const dirs = [
+    join3(home, ".qoder", "logs", "sessions"),
+    ...windowsHomes.flatMap((windowsHome) => [
+      join3(windowsHome, ".qoder", "logs", "sessions"),
+      join3(windowsHome, "AppData", "Local", ".qoder", "logs", "sessions"),
+      join3(windowsHome, "AppData", "Roaming", "Qoder", "logs", "sessions")
+    ])
+  ];
+  if (process.env.LOCALAPPDATA) {
+    dirs.push(join3(process.env.LOCALAPPDATA, ".qoder", "logs", "sessions"));
+  }
+  if (process.env.APPDATA) {
+    dirs.push(join3(process.env.APPDATA, "Qoder", "logs", "sessions"));
+  }
+  return unique(dirs);
+}
+function qoderSessionDirs(source, home) {
+  if (!source) return defaultQoderSessionDirs(home);
+  const normalized = source.replace(/\\/g, "/").replace(/\/+$/, "");
+  if (normalized.endsWith("/logs/sessions") || normalized.endsWith("/sessions") || normalized.endsWith("/segments")) {
+    return [source];
+  }
+  if (normalized.endsWith("/logs")) return [join3(source, "sessions")];
+  return [join3(source, "logs", "sessions")];
+}
+function defaultOpenCodeDbPath() {
+  const home = homedir2();
+  const plat = platform();
+  if (plat === "win32") {
+    const appData = process.env.APPDATA ?? join3(home, "AppData", "Roaming");
+    return join3(appData, "opencode", "opencode.db");
+  }
+  if (plat === "darwin") {
+    return join3(home, "Library", "Application Support", "opencode", "opencode.db");
+  }
+  const xdgDataHome = process.env.XDG_DATA_HOME ?? join3(home, ".local", "share");
+  return join3(xdgDataHome, "opencode", "opencode.db");
+}
+function defaultHermesDbPath() {
+  return join3(homedir2(), ".hermes", "state.db");
+}
+function defaultQoderDbPath() {
+  const home = homedir2();
+  const plat = platform();
+  if (plat === "darwin") {
+    return join3(home, "Library", "Application Support", "Qoder", "SharedClientCache", "cache", "db", "local.db");
+  }
+  if (plat === "win32") {
+    const localAppData = process.env.LOCALAPPDATA ?? join3(home, "AppData", "Local");
+    return join3(localAppData, "Qoder", "SharedClientCache", "cache", "db", "local.db");
+  }
+  const xdgDataHome = process.env.XDG_DATA_HOME ?? join3(home, ".local", "share");
+  return join3(xdgDataHome, "Qoder", "SharedClientCache", "cache", "db", "local.db");
+}
+function discoverLogFiles(sources) {
+  const home = homedir2();
+  const results = [];
+  const claudeDir = sources?.["claude-code"] ?? join3(home, ".claude", "projects");
+  if (existsSync4(claudeDir)) {
+    const claudePaths = findJsonlFiles(claudeDir);
+    if (claudePaths.length > 0) {
+      results.push({ tool: "claude-code", paths: claudePaths });
+    }
+  }
+  const codexDir = sources?.["codex"] ?? join3(home, ".codex", "sessions");
+  if (existsSync4(codexDir)) {
+    const codexPaths = findJsonlFiles(codexDir);
+    if (codexPaths.length > 0) {
+      results.push({ tool: "codex", paths: codexPaths });
+    }
+  }
+  const openclawBase = sources?.["openclaw"] ?? join3(home, ".openclaw", "agents");
+  if (existsSync4(openclawBase)) {
+    let openclawPaths;
+    if (sources?.["openclaw"]) {
+      openclawPaths = findJsonlFiles(openclawBase).filter((p) => !p.includes(".checkpoint."));
+    } else {
+      openclawPaths = [];
+      try {
+        const agentEntries = readdirSync(openclawBase, { withFileTypes: true });
+        for (const agentEntry of agentEntries) {
+          if (!agentEntry.isDirectory()) continue;
+          const sessionsDir = join3(openclawBase, agentEntry.name, "sessions");
+          if (existsSync4(sessionsDir)) {
+            openclawPaths.push(...findJsonlFiles(sessionsDir).filter((p) => !p.includes(".checkpoint.")));
           }
         }
-        const devices = [...deviceMap.values()].sort((a, b) => b.recordCount - a.recordCount);
-        json(res, { currentDeviceInstanceId: currentId, devices });
-        return;
+      } catch {
       }
-      if (url.pathname === "/api/config/credential" && req.method === "GET") {
-        const ref = url.searchParams.get("ref")?.trim();
-        if (!ref) {
-          json(res, { error: { code: "MISSING_CREDENTIAL_REF", message: "credential ref is required" } }, 400);
-          return;
-        }
-        const value = loadCredential(ref);
-        if (!value) {
-          json(res, { error: { code: "CREDENTIAL_NOT_FOUND", message: "Credential not found" } }, 404);
-          return;
+    }
+    if (openclawPaths.length > 0) {
+      results.push({ tool: "openclaw", paths: openclawPaths });
+    }
+  }
+  const qoderPaths = unique(
+    qoderSessionDirs(sources?.["qoder"], home).filter((dir) => existsSync4(dir)).flatMap((dir) => findQoderSessionSegmentFiles(dir))
+  );
+  if (qoderPaths.length > 0) {
+    results.push({ tool: "qoder", paths: qoderPaths });
+  }
+  return results;
+}
+function extractSessionId(filePath, tool) {
+  if (tool === "claude-code") {
+    const parts = filePath.split("/");
+    const filename = parts[parts.length - 1];
+    return filename.replace(".jsonl", "");
+  }
+  if (tool === "codex") {
+    const filename = filePath.split("/").pop() ?? "";
+    const match = filename.match(/rollout-(.+)\.jsonl$/);
+    return match ? match[1] : filename.replace(".jsonl", "");
+  }
+  if (tool === "openclaw") {
+    const filename = filePath.split("/").pop() ?? "";
+    return filename.replace(".jsonl", "");
+  }
+  if (tool === "qoder") {
+    const parts = filePath.replace(/\\/g, "/").split("/").filter(Boolean);
+    const segmentsIndex = parts.lastIndexOf("segments");
+    if (segmentsIndex > 0) return parts[segmentsIndex - 1];
+    const filename = parts[parts.length - 1] ?? "";
+    return filename.replace(".jsonl", "") || "unknown";
+  }
+  return "unknown";
+}
+async function runParse(db, filterTool, options) {
+  const state = getState(AIUSAGE_DIR);
+  const config = loadConfig();
+  const exchangeRate = resolveExchangeRate(config ?? {});
+  const device = config?.device || hostname() || state?.deviceInstanceId?.slice(0, 8) || "unknown";
+  const deviceInstanceId = state?.deviceInstanceId ?? "unknown";
+  const devicePlatform = config?.platform;
+  const watermarkPath = join3(AIUSAGE_DIR, "watermark.json");
+  const wm = new WatermarkManager(watermarkPath);
+  const toolPaths = discoverLogFiles(config?.sources);
+  const aggregator = new Aggregator();
+  let parsedCount = 0;
+  let toolCallCount = 0;
+  const errors = [];
+  const onProgress = options?.onProgress ?? (() => {
+  });
+  const totalFiles = toolPaths.filter(({ tool }) => !filterTool || tool === filterTool).reduce((sum, { paths }) => sum + paths.length, 0);
+  let fileIndex = 0;
+  let currentTool;
+  for (const { tool, paths } of toolPaths) {
+    if (filterTool && tool !== filterTool) continue;
+    currentTool = tool;
+    for (const filePath of paths) {
+      fileIndex++;
+      try {
+        const stat2 = statSync(filePath);
+        const entry = wm.getEntry(tool, filePath);
+        const offset = entry?.offset ?? 0;
+        if (offset >= stat2.size) {
+          onProgress({ phase: "Parsing logs", tool, current: fileIndex, total: totalFiles, records: parsedCount, toolCalls: toolCallCount });
+          continue;
         }
-        json(res, { value });
-        return;
-      }
-      if (url.pathname === "/api/config") {
-        if (req.method === "GET") {
-          const currentCfg = loadConfig() ?? {};
-          const { credentials, priceOverrides, platform: platform4, ...rest } = currentCfg;
-          json(res, {
-            device: rest.device ?? null,
-            weekStart: rest.weekStart ?? 1,
-            dashboardPollInterval: rest.dashboardPollInterval ?? null,
-            parseInterval: rest.parseInterval ?? null,
-            retentionDays: rest.retentionDays ?? null,
-            sources: {
-              "claude-code": rest.sources?.["claude-code"] ?? null,
-              codex: rest.sources?.codex ?? null,
-              openclaw: rest.sources?.openclaw ?? null,
-              opencode: rest.sources?.opencode ?? null
-            },
-            sync: rest.sync ?? null,
-            credentialKeys: credentials ? Object.keys(credentials) : []
-          });
-          return;
+        const content = readFileSync4(filePath, "utf-8");
+        const lines = content.split("\n");
+        let byteOffset = 0;
+        let fileCwd;
+        try {
+          const firstData = JSON.parse(lines[0]);
+          if (typeof firstData.cwd === "string" && firstData.cwd) fileCwd = firstData.cwd;
+        } catch {
         }
-        if (req.method === "PUT") {
-          let body = "";
-          for await (const chunk of req) body += chunk;
-          try {
-            const update = JSON.parse(body);
-            const existing = loadConfig() ?? {};
-            if ("device" in update) {
-              if (!update.device) delete existing.device;
-              else existing.device = String(update.device);
-            }
-            if ("weekStart" in update) {
-              const ws = Number(update.weekStart);
-              if (ws === 0 || ws === 1) {
-                existing.weekStart = ws;
-                weekStart = ws;
-              } else {
-                delete existing.weekStart;
-              }
-            }
-            if ("dashboardPollInterval" in update) {
-              if (!update.dashboardPollInterval) delete existing.dashboardPollInterval;
-              else existing.dashboardPollInterval = Number(update.dashboardPollInterval);
-            }
-            if ("parseInterval" in update) {
-              if (!update.parseInterval) delete existing.parseInterval;
-              else existing.parseInterval = Number(update.parseInterval);
-            }
-            if ("retentionDays" in update) {
-              if (!update.retentionDays) delete existing.retentionDays;
-              else existing.retentionDays = Number(update.retentionDays);
-            }
-            if (update.sources && typeof update.sources === "object") {
-              const src = update.sources;
-              const s = existing.sources ?? {};
-              for (const key of ["claude-code", "codex", "openclaw", "opencode"]) {
-                if (key in src) {
-                  if (!src[key]) delete s[key];
-                  else s[key] = String(src[key]);
-                }
-              }
-              if (Object.keys(s).length) existing.sources = s;
-              else delete existing.sources;
-            }
-            if ("sync" in update) {
-              const syncUpdate = update.sync;
-              if (!syncUpdate?.backend) {
-                delete existing.sync;
-              } else {
-                const backendVal = String(syncUpdate.backend);
-                if (backendVal !== "github" && backendVal !== "s3") {
-                  json(res, { error: { code: "INVALID_BACKEND", message: "sync.backend must be github or s3" } }, 400);
-                  return;
-                }
-                const newSync = { backend: backendVal };
-                for (const f of ["repo", "bucket", "prefix", "endpoint", "region", "credentialRef"]) {
-                  if (syncUpdate[f]) newSync[f] = String(syncUpdate[f]);
-                }
-                existing.sync = newSync;
-              }
+        const sessionId = extractSessionId(filePath, tool);
+        for (const line of lines) {
+          if (!line.trim()) {
+            byteOffset += Buffer.byteLength(line, "utf-8") + 1;
+            continue;
+          }
+          if (byteOffset < offset) {
+            byteOffset += Buffer.byteLength(line, "utf-8") + 1;
+            continue;
+          }
+          const context = aggregator.createContext({
+            tool,
+            sourceFile: filePath,
+            lineOffset: byteOffset,
+            sessionId,
+            device,
+            deviceInstanceId,
+            platform: devicePlatform,
+            exchangeRate
+          });
+          const result = aggregator.parseLine(line, context);
+          if (result) {
+            if (result.record) {
+              insertRecord(db, result.record);
+              parsedCount++;
             }
-            if (update.credentials && typeof update.credentials === "object") {
-              const creds = update.credentials;
-              const c = existing.credentials ?? {};
-              for (const [key, val] of Object.entries(creds)) {
-                if (val !== "" && val !== null && val !== void 0) {
-                  c[key] = String(val);
-                }
-              }
-              if (Object.keys(c).length) existing.credentials = c;
-              else delete existing.credentials;
+            for (const tc of result.toolCalls) {
+              insertToolCall(db, tc);
+              toolCallCount++;
             }
-            saveConfig(existing);
-            options?.onConfigUpdated?.();
-            json(res, { ok: true });
-          } catch {
-            json(res, { error: { code: "INVALID_JSON", message: "Invalid JSON body" } }, 400);
           }
-          return;
+          byteOffset += Buffer.byteLength(line, "utf-8") + 1;
+        }
+        const orphanResults = aggregator.finalize();
+        for (const result of orphanResults) {
+          for (const tc of result.toolCalls) {
+            insertToolCall(db, tc);
+            toolCallCount++;
+          }
+        }
+        if (fileCwd) {
+          db.prepare(`UPDATE records SET cwd = ? WHERE source_file = ? AND cwd = ''`).run(fileCwd, filePath);
         }
+        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 });
+      } catch (e) {
+        errors.push(`${filePath}: ${e instanceof Error ? e.message : e}`);
       }
-      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 Database from "better-sqlite3";
-import { readFileSync as readFileSync4, readdirSync, statSync, existsSync as existsSync4 } from "fs";
-import { join as join3, extname } from "path";
-import { homedir as homedir2, hostname as hostname2, platform as platform2 } 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, device, device_instance_id, platform
-    ) VALUES (
-      @id, @ts, @ingestedAt, @syncedAt, @updatedAt, @lineOffset,
-      @tool, @model, @provider, @inputTokens, @outputTokens,
-      @cacheReadTokens, @cacheWriteTokens, @thinkingTokens,
-      @cost, @costSource, @sessionId, @sourceFile, @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,
-    device: record.device,
-    deviceInstanceId: record.deviceInstanceId,
-    platform: record.platform ?? ""
-  });
-}
-function getUnsyncedRecords(db) {
-  const rows = db.prepare(
-    "SELECT * FROM records WHERE synced_at IS NULL OR updated_at > synced_at"
+  }
+  const openCodeDbPath = options?.openCodeDbPath ?? config?.sources?.["opencode"] ?? defaultOpenCodeDbPath();
+  if ((!filterTool || filterTool === "opencode") && existsSync4(openCodeDbPath)) {
+    try {
+      const openCodeDb = new Database(openCodeDbPath, { readonly: true });
+      try {
+        const result = runParseOpenCode(openCodeDb, {
+          dbPath: openCodeDbPath,
+          device,
+          deviceInstanceId,
+          platform: devicePlatform,
+          now: Date.now(),
+          cursor: wm.getOpenCodeCursor(),
+          exchangeRate
+        });
+        for (const record of result.records) insertRecord(db, record);
+        for (const tc of result.toolCalls) insertToolCall(db, tc);
+        if (result.nextCursor) {
+          wm.setOpenCodeCursor(result.nextCursor);
+          wm.save();
+        }
+        parsedCount += result.records.length;
+        toolCallCount += result.toolCalls.length;
+        errors.push(...result.errors);
+        onProgress({ phase: "Parsing SQLite", tool: "opencode", current: 1, total: 1, records: parsedCount, toolCalls: toolCallCount });
+      } finally {
+        openCodeDb.close();
+      }
+    } catch (e) {
+      errors.push(`${openCodeDbPath}: ${e instanceof Error ? e.message : e}`);
+    }
+  }
+  const hermesDbPath = options?.hermesDbPath ?? config?.sources?.["hermes"] ?? defaultHermesDbPath();
+  if ((!filterTool || filterTool === "hermes") && existsSync4(hermesDbPath)) {
+    try {
+      const hermesDb = new Database(hermesDbPath, { readonly: true });
+      try {
+        const result = runParseHermes(hermesDb, {
+          dbPath: hermesDbPath,
+          device,
+          deviceInstanceId,
+          platform: devicePlatform,
+          now: Date.now(),
+          cursor: wm.getHermesCursor(),
+          exchangeRate
+        });
+        for (const record of result.records) insertRecord(db, record);
+        for (const tc of result.toolCalls) insertToolCall(db, tc);
+        if (result.nextCursor) {
+          wm.setHermesCursor(result.nextCursor);
+          wm.save();
+        }
+        parsedCount += result.records.length;
+        toolCallCount += result.toolCalls.length;
+        errors.push(...result.errors);
+        onProgress({ phase: "Parsing SQLite", tool: "hermes", current: 1, total: 1, records: parsedCount, toolCalls: toolCallCount });
+      } finally {
+        hermesDb.close();
+      }
+    } catch (e) {
+      errors.push(`${hermesDbPath}: ${e instanceof Error ? e.message : e}`);
+    }
+  }
+  const qoderDbPath = options?.qoderDbPath ?? config?.sources?.["qoder-db"] ?? defaultQoderDbPath();
+  if ((!filterTool || filterTool === "qoder") && existsSync4(qoderDbPath)) {
+    try {
+      const qoderDb = new Database(qoderDbPath, { readonly: true });
+      try {
+        const result = runParseQoder(qoderDb, {
+          dbPath: qoderDbPath,
+          device,
+          deviceInstanceId,
+          platform: devicePlatform,
+          now: Date.now(),
+          cursor: wm.getQoderCursor(),
+          exchangeRate
+        });
+        for (const record of result.records) insertRecord(db, record);
+        for (const tc of result.toolCalls) insertToolCall(db, tc);
+        if (result.nextCursor) {
+          wm.setQoderCursor(result.nextCursor);
+          wm.save();
+        }
+        parsedCount += result.records.length;
+        toolCallCount += result.toolCalls.length;
+        errors.push(...result.errors);
+        onProgress({ phase: "Parsing SQLite", tool: "qoder", current: 1, total: 1, records: parsedCount, toolCalls: toolCallCount });
+      } finally {
+        qoderDb.close();
+      }
+    } catch (e) {
+      errors.push(`${qoderDbPath}: ${e instanceof Error ? e.message : e}`);
+    }
+  }
+  if (deviceInstanceId !== "unknown") {
+    db.prepare(
+      `UPDATE records SET device_instance_id = ?, device = ? WHERE device_instance_id = 'unknown'`
+    ).run(deviceInstanceId, device);
+  }
+  if (devicePlatform) {
+    db.prepare(
+      `UPDATE records SET platform = ? WHERE platform = '' AND source_file NOT LIKE 'synced/%'`
+    ).run(devicePlatform);
+  }
+  const staleFiles = db.prepare(
+    `SELECT DISTINCT source_file FROM records WHERE cwd = '' AND source_file NOT LIKE 'synced/%'`
   ).all();
-  return rows.map(mapRowToRecord);
+  for (const { source_file } of staleFiles) {
+    try {
+      const fd = openSync(source_file, "r");
+      const buf = Buffer.alloc(2048);
+      const n = readSync(fd, buf, 0, 2048, 0);
+      closeSync(fd);
+      const firstLine = buf.subarray(0, n).toString("utf8").split("\n")[0];
+      const data = JSON.parse(firstLine);
+      if (typeof data.cwd === "string" && data.cwd) {
+        db.prepare(`UPDATE records SET cwd = ? WHERE source_file = ? AND cwd = ''`).run(data.cwd, source_file);
+      }
+    } catch {
+    }
+  }
+  return { parsedCount, toolCallCount, errors };
 }
-function mapRowToRecord(row) {
+function getDefaultSourcePaths() {
+  const home = homedir2();
   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,
-    device: row.device,
-    deviceInstanceId: row.device_instance_id,
-    platform: row.platform || void 0
+    "claude-code": join3(home, ".claude", "projects"),
+    "codex": join3(home, ".codex", "sessions"),
+    "openclaw": join3(home, ".openclaw", "agents"),
+    "opencode": defaultOpenCodeDbPath(),
+    "hermes": defaultHermesDbPath(),
+    "qoder": join3(home, ".qoder", "logs", "sessions"),
+    "qoder-db": defaultQoderDbPath()
   };
 }
 
-// src/db/tool-calls.ts
-function insertToolCall(db, tc) {
-  db.prepare(`
-    INSERT OR REPLACE INTO tool_calls (id, record_id, tool, name, ts, call_index)
-    VALUES (@id, @recordId, @tool, @name, @ts, @callIndex)
-  `).run({
-    id: tc.id,
-    recordId: tc.recordId ?? null,
-    tool: tc.recordId ? null : tc.tool,
-    name: tc.name,
-    ts: tc.ts,
-    callIndex: tc.callIndex
-  });
-}
-function getToolCallStats(db) {
-  return db.prepare(`
-    SELECT name, COUNT(*) as count
-    FROM tool_calls
-    GROUP BY name
-    ORDER BY count DESC
-  `).all();
-}
-
-// src/init.ts
-import { mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
-import { randomUUID } from "crypto";
-function getState(aiusageDir) {
-  const statePath = join2(aiusageDir, "state.json");
-  if (!existsSync2(statePath)) return null;
-  try {
-    const content = readFileSync2(statePath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
+// src/api/server.ts
+function getDateRangeFilter(range, from, to, prefix = "", weekStart = 1) {
+  const ts = 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 ${ts} >= @start AND ${ts} < @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 ${ts} >= @start`, params: { start: startOfWeek.getTime() } };
+  }
+  if (range === "month") {
+    const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+    return { where: `AND ${ts} >= @start`, params: { start: startOfMonth.getTime() } };
+  }
+  if (range === "last30") {
+    const start = new Date(today);
+    start.setDate(start.getDate() - 30);
+    return { where: `AND ${ts} >= @start`, params: { start: start.getTime() } };
+  }
+  if (range === "all") {
+    return { where: "", params: {} };
+  }
+  return { where: `AND ${ts} >= @start`, params: { start: today.getTime() } };
 }
-function setState(aiusageDir, updates) {
-  const statePath = join2(aiusageDir, "state.json");
-  const current = getState(aiusageDir) ?? {
-    deviceInstanceId: randomUUID(),
-    lastSyncStatus: "ok"
-  };
-  const updated = { ...current, ...updates };
-  writeFileSync2(statePath, JSON.stringify(updated, null, 2), "utf-8");
+function json(res, data, status = 200) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
 }
-
-// src/watermark.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3 } from "fs";
-function defaultFileData() {
+function getToolFilter(tool, prefix = "") {
+  if (!tool) return { where: "", params: {} };
+  const col = prefix ? `${prefix}.tool` : "tool";
+  return { where: `AND ${col} = @tool`, params: { tool } };
+}
+var LOCAL_ONLY_FILTER = "AND source_file NOT LIKE 'synced/%'";
+function getDeviceFilter(device, currentDeviceInstanceId) {
+  if (!currentDeviceInstanceId) {
+    return { where: "", params: {}, useUnion: false, localOnly: false };
+  }
+  if (!device) {
+    return {
+      where: "",
+      params: { currentDeviceId: currentDeviceInstanceId },
+      useUnion: true,
+      localOnly: true
+    };
+  }
+  if (device === currentDeviceInstanceId) {
+    return { where: "", params: {}, useUnion: false, localOnly: true };
+  }
   return {
-    "claude-code": {},
-    "codex": {},
-    "openclaw": {},
-    "opencode": {},
-    "hermes": {}
+    where: "AND device_instance_id = @deviceId",
+    params: { deviceId: device },
+    useUnion: false,
+    localOnly: false
   };
 }
-var WatermarkManager = class {
-  data;
-  path;
-  constructor(path2) {
-    this.path = path2;
-    this.data = this.load();
-  }
-  load() {
-    if (!existsSync3(this.path)) {
-      return { files: defaultFileData() };
+function createApiServer(db, options) {
+  const cfg = loadConfig();
+  let weekStart = cfg?.weekStart ?? 1;
+  const server = http.createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const range = url.searchParams.get("range");
+    const from = url.searchParams.get("from");
+    const to = url.searchParams.get("to");
+    const toolParam = url.searchParams.get("tool");
+    const VALID_TOOLS = ["claude-code", "codex", "openclaw", "opencode", "hermes", "qoder"];
+    if (toolParam && !VALID_TOOLS.includes(toolParam)) {
+      json(res, { error: { code: "INVALID_PARAM", message: "Invalid tool" } }, 400);
+      return;
     }
     try {
-      const content = readFileSync3(this.path, "utf-8");
-      const parsed = JSON.parse(content);
-      if (parsed && typeof parsed === "object" && !("files" in parsed)) {
-        return { files: { ...defaultFileData(), ...parsed } };
+      if (url.pathname === "/api/summary") {
+        if (range && !["day", "week", "month", "last30", "all"].includes(range)) {
+          json(res, { error: { code: "INVALID_PARAM", message: "Invalid range" } }, 400);
+          return;
+        }
+        const device = url.searchParams.get("device");
+        const df = getDeviceFilter(device, options?.currentDeviceInstanceId);
+        const dr = getDateRangeFilter(range, from, to, "", weekStart);
+        const tool = url.searchParams.get("tool");
+        const tf = getToolFilter(tool);
+        let totals;
+        let byToolRows;
+        if (df.useUnion) {
+          const unionSql = `
+            SELECT input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens, cost, ts, session_id
+            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+            UNION ALL
+            SELECT input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens, cost, ts, session_key AS session_id
+            FROM synced_records WHERE device_instance_id != @currentDeviceId ${dr.where} ${tf.where}
+          `;
+          totals = db.prepare(`
+            SELECT
+              COALESCE(SUM(input_tokens), 0) AS inputTokens,
+              COALESCE(SUM(output_tokens), 0) AS outputTokens,
+              COALESCE(SUM(cache_read_tokens), 0) AS cacheReadTokens,
+              COALESCE(SUM(cache_write_tokens), 0) AS cacheWriteTokens,
+              COALESCE(SUM(thinking_tokens), 0) AS thinkingTokens,
+              COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens), 0) AS totalTokens,
+              COALESCE(SUM(cost), 0) AS totalCost,
+              COUNT(DISTINCT strftime('%Y-%m-%d', ts/1000, 'unixepoch')) AS activeDays,
+              COUNT(DISTINCT session_id) AS totalSessions
+            FROM (${unionSql})
+          `).get({ ...dr.params, ...df.params, ...tf.params });
+          byToolRows = db.prepare(`
+            SELECT tool, SUM(tokens) AS tokens, SUM(cost) AS cost FROM (
+              SELECT tool,
+                     SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS tokens,
+                     SUM(cost) AS cost
+              FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+              GROUP BY tool
+              UNION ALL
+              SELECT tool,
+                     SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS tokens,
+                     SUM(cost) AS cost
+              FROM synced_records WHERE device_instance_id != @currentDeviceId ${dr.where} ${tf.where}
+              GROUP BY tool
+            ) GROUP BY tool ORDER BY cost DESC
+          `).all({ ...dr.params, ...df.params, ...tf.params });
+        } else if (df.where) {
+          totals = db.prepare(`
+            SELECT
+              COALESCE(SUM(input_tokens), 0) AS inputTokens,
+              COALESCE(SUM(output_tokens), 0) AS outputTokens,
+              COALESCE(SUM(cache_read_tokens), 0) AS cacheReadTokens,
+              COALESCE(SUM(cache_write_tokens), 0) AS cacheWriteTokens,
+              COALESCE(SUM(thinking_tokens), 0) AS thinkingTokens,
+              COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens), 0) AS totalTokens,
+              COALESCE(SUM(cost), 0) AS totalCost,
+              COUNT(DISTINCT strftime('%Y-%m-%d', ts/1000, 'unixepoch')) AS activeDays,
+              COUNT(DISTINCT session_key) AS totalSessions
+            FROM synced_records WHERE 1=1 ${df.where} ${dr.where} ${tf.where}
+          `).get({ ...dr.params, ...df.params, ...tf.params });
+          byToolRows = db.prepare(`
+            SELECT tool,
+                   SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS tokens,
+                   SUM(cost) AS cost
+            FROM synced_records WHERE 1=1 ${df.where} ${dr.where} ${tf.where}
+            GROUP BY tool ORDER BY cost DESC
+          `).all({ ...dr.params, ...df.params, ...tf.params });
+        } else {
+          totals = db.prepare(`
+            SELECT
+              COALESCE(SUM(input_tokens), 0) AS inputTokens,
+              COALESCE(SUM(output_tokens), 0) AS outputTokens,
+              COALESCE(SUM(cache_read_tokens), 0) AS cacheReadTokens,
+              COALESCE(SUM(cache_write_tokens), 0) AS cacheWriteTokens,
+              COALESCE(SUM(thinking_tokens), 0) AS thinkingTokens,
+              COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens), 0) AS totalTokens,
+              COALESCE(SUM(cost), 0) AS totalCost,
+              COUNT(DISTINCT strftime('%Y-%m-%d', ts/1000, 'unixepoch')) AS activeDays,
+              COUNT(DISTINCT session_id) AS totalSessions
+            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+          `).get({ ...dr.params, ...tf.params });
+          byToolRows = db.prepare(`
+            SELECT tool,
+                   SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS tokens,
+                   SUM(cost) AS cost
+            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+            GROUP BY tool ORDER BY cost DESC
+          `).all({ ...dr.params, ...tf.params });
+        }
+        const byTool = {};
+        for (const row of byToolRows) {
+          byTool[row.tool] = { tokens: row.tokens, cost: row.cost };
+        }
+        const drJoin = getDateRangeFilter(range, from, to, "r", weekStart);
+        const dfJoin = df.where ? df.where.replace(/device_instance_id/g, "r.device_instance_id") : "";
+        const tfJoin = getToolFilter(tool, "r");
+        const topToolCalls = db.prepare(`
+          SELECT tc.name, COUNT(*) AS count
+          FROM tool_calls tc
+          JOIN records r ON r.id = tc.record_id
+          WHERE 1=1 ${dfJoin} ${drJoin.where} ${tfJoin.where}
+          GROUP BY tc.name ORDER BY count DESC LIMIT 10
+        `).all({ ...drJoin.params, ...df.params, ...tfJoin.params });
+        json(res, {
+          inputTokens: totals.inputTokens,
+          outputTokens: totals.outputTokens,
+          cacheReadTokens: totals.cacheReadTokens,
+          cacheWriteTokens: totals.cacheWriteTokens,
+          thinkingTokens: totals.thinkingTokens,
+          totalTokens: totals.totalTokens,
+          totalCost: totals.totalCost,
+          activeDays: totals.activeDays,
+          totalSessions: totals.totalSessions,
+          byTool,
+          topToolCalls
+        });
+        return;
+      }
+      if (url.pathname === "/api/tokens") {
+        const dr = getDateRangeFilter(range, from, to, "", weekStart);
+        const device = url.searchParams.get("device");
+        const df = getDeviceFilter(device, options?.currentDeviceInstanceId);
+        const tool = url.searchParams.get("tool");
+        const tf = getToolFilter(tool);
+        let sql;
+        let params;
+        if (df.useUnion) {
+          sql = `
+            SELECT strftime('%Y-%m-%d', ts/1000, 'unixepoch') AS date,
+                   SUM(input_tokens) AS inputTokens,
+                   SUM(output_tokens) AS outputTokens,
+                   SUM(cache_read_tokens) AS cacheReadTokens,
+                   SUM(cache_write_tokens) AS cacheWriteTokens,
+                   SUM(thinking_tokens) AS thinkingTokens
+            FROM (
+              SELECT input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens, ts FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+              UNION ALL
+              SELECT input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens, ts FROM synced_records WHERE device_instance_id != @currentDeviceId ${dr.where} ${tf.where}
+            )
+            GROUP BY date ORDER BY date`;
+          params = { ...dr.params, currentDeviceId: df.params.currentDeviceId, ...tf.params };
+        } else if (device && device !== options?.currentDeviceInstanceId) {
+          sql = `
+            SELECT strftime('%Y-%m-%d', ts/1000, 'unixepoch') AS date,
+                   SUM(input_tokens) AS inputTokens,
+                   SUM(output_tokens) AS outputTokens,
+                   SUM(cache_read_tokens) AS cacheReadTokens,
+                   SUM(cache_write_tokens) AS cacheWriteTokens,
+                   SUM(thinking_tokens) AS thinkingTokens
+            FROM synced_records WHERE 1=1 ${df.where} ${dr.where} ${tf.where}
+            GROUP BY date ORDER BY date`;
+          params = { ...df.params, ...dr.params, ...tf.params };
+        } else {
+          sql = `
+            SELECT strftime('%Y-%m-%d', ts/1000, 'unixepoch') AS date,
+                   SUM(input_tokens) AS inputTokens,
+                   SUM(output_tokens) AS outputTokens,
+                   SUM(cache_read_tokens) AS cacheReadTokens,
+                   SUM(cache_write_tokens) AS cacheWriteTokens,
+                   SUM(thinking_tokens) AS thinkingTokens
+            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+            GROUP BY date ORDER BY date`;
+          params = { ...dr.params, ...tf.params };
+        }
+        const rows = db.prepare(sql).all(params);
+        json(res, { data: rows });
+        return;
       }
-      return { files: parsed.files ?? defaultFileData(), opencode: parsed.opencode ?? null, hermes: parsed.hermes ?? null };
-    } catch {
-      return { files: defaultFileData() };
-    }
-  }
-  save() {
-    writeFileSync3(this.path, JSON.stringify(this.data, null, 2), "utf-8");
-  }
-  getEntry(tool, filePath) {
-    return this.data.files[tool]?.[filePath] ?? null;
-  }
-  setEntry(tool, filePath, entry) {
-    if (!this.data.files[tool]) {
-      this.data.files[tool] = {};
-    }
-    this.data.files[tool][filePath] = entry;
-  }
-  cleanup(existingFiles) {
-    const existingSet = new Set(existingFiles);
-    for (const tool of Object.keys(this.data.files)) {
-      for (const filePath of Object.keys(this.data.files[tool])) {
-        if (!existingSet.has(filePath)) {
-          delete this.data.files[tool][filePath];
+      if (url.pathname === "/api/cost") {
+        const dr = getDateRangeFilter(range, from, to, "", weekStart);
+        const device = url.searchParams.get("device");
+        const df = getDeviceFilter(device, options?.currentDeviceInstanceId);
+        const tool = url.searchParams.get("tool");
+        const tf = getToolFilter(tool);
+        let daily;
+        let byToolRows;
+        let byModelRows;
+        if (df.useUnion) {
+          daily = db.prepare(`
+            SELECT strftime('%Y-%m-%d', ts/1000, 'unixepoch') AS date,
+                   SUM(cost) AS cost
+            FROM (
+              SELECT cost, ts FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+              UNION ALL
+              SELECT cost, ts FROM synced_records WHERE device_instance_id != @currentDeviceId ${dr.where} ${tf.where}
+            )
+            GROUP BY date ORDER BY date
+          `).all({ ...dr.params, currentDeviceId: df.params.currentDeviceId, ...tf.params });
+          byToolRows = db.prepare(`
+            SELECT tool, SUM(cost) AS cost FROM (
+              SELECT tool, SUM(cost) AS cost FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where} GROUP BY tool
+              UNION ALL
+              SELECT tool, SUM(cost) AS cost FROM synced_records WHERE device_instance_id != @currentDeviceId ${dr.where} ${tf.where} GROUP BY tool
+            ) GROUP BY tool ORDER BY cost DESC
+          `).all({ ...dr.params, currentDeviceId: df.params.currentDeviceId, ...tf.params });
+          byModelRows = db.prepare(`
+            SELECT model, SUM(cost) AS cost FROM (
+              SELECT model, SUM(cost) AS cost FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where} GROUP BY model
+              UNION ALL
+              SELECT model, SUM(cost) AS cost FROM synced_records WHERE device_instance_id != @currentDeviceId ${dr.where} ${tf.where} GROUP BY model
+            ) GROUP BY model ORDER BY cost DESC
+          `).all({ ...dr.params, currentDeviceId: df.params.currentDeviceId, ...tf.params });
+        } else if (device && device !== options?.currentDeviceInstanceId) {
+          daily = db.prepare(`
+            SELECT strftime('%Y-%m-%d', ts/1000, 'unixepoch') AS date,
+                   SUM(cost) AS cost
+            FROM synced_records WHERE 1=1 ${df.where} ${dr.where} ${tf.where}
+            GROUP BY date ORDER BY date
+          `).all({ ...df.params, ...dr.params, ...tf.params });
+          byToolRows = db.prepare(`
+            SELECT tool, SUM(cost) AS cost
+            FROM synced_records WHERE 1=1 ${df.where} ${dr.where} ${tf.where}
+            GROUP BY tool ORDER BY cost DESC
+          `).all({ ...df.params, ...dr.params, ...tf.params });
+          byModelRows = db.prepare(`
+            SELECT model, SUM(cost) AS cost
+            FROM synced_records WHERE 1=1 ${df.where} ${dr.where} ${tf.where}
+            GROUP BY model ORDER BY cost DESC
+          `).all({ ...df.params, ...dr.params, ...tf.params });
+        } else {
+          daily = db.prepare(`
+            SELECT strftime('%Y-%m-%d', ts/1000, 'unixepoch') AS date,
+                   SUM(cost) AS cost
+            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+            GROUP BY date ORDER BY date
+          `).all({ ...dr.params, ...tf.params });
+          byToolRows = db.prepare(`
+            SELECT tool, SUM(cost) AS cost
+            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+            GROUP BY tool ORDER BY cost DESC
+          `).all({ ...dr.params, ...tf.params });
+          byModelRows = db.prepare(`
+            SELECT model, SUM(cost) AS cost
+            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+            GROUP BY model ORDER BY cost DESC
+          `).all({ ...dr.params, ...tf.params });
         }
+        const byTool = {};
+        for (const r of byToolRows) byTool[r.tool] = r.cost;
+        const byModel = {};
+        for (const r of byModelRows) byModel[r.model] = r.cost;
+        json(res, { data: daily, byTool, byModel });
+        return;
       }
-    }
-  }
-  getOpenCodeCursor() {
-    return this.data.opencode ?? null;
-  }
-  setOpenCodeCursor(cursor) {
-    this.data.opencode = cursor;
-  }
-  getHermesCursor() {
-    return this.data.hermes ?? null;
-  }
-  setHermesCursor(cursor) {
-    this.data.hermes = cursor;
-  }
-};
-
-// src/commands/parse-opencode.ts
-function runParseOpenCode(db, options) {
-  const { dbPath, device, deviceInstanceId, platform: platform4, now, cursor } = options;
-  const records = [];
-  const toolCalls = [];
-  const errors = [];
-  let lastCursor = null;
-  const messages = db.prepare(
-    `SELECT m.id, m.session_id, m.time_created, m.data
-       FROM message m
-       WHERE m.time_created > ? OR (m.time_created = ? AND m.id > ?)
-       ORDER BY m.time_created, m.id`
-  ).all(
-    cursor?.lastMessageCreatedAt ?? 0,
-    cursor?.lastMessageCreatedAt ?? 0,
-    cursor?.lastMessageId ?? ""
-  );
-  const partsStmt = db.prepare(
-    `SELECT id, message_id, session_id, time_created, data
-     FROM part
-     WHERE message_id = ?
-     ORDER BY time_created, id`
-  );
-  for (const message of messages) {
-    lastCursor = {
-      lastMessageCreatedAt: message.time_created,
-      lastMessageId: message.id
-    };
-    let parsed;
-    try {
-      parsed = JSON.parse(message.data);
-    } catch (e) {
-      errors.push(`message ${message.id}: invalid JSON: ${e instanceof Error ? e.message : e}`);
-      continue;
-    }
-    if (parsed.role !== "assistant" || !parsed.tokens) continue;
-    const inputTokens = parsed.tokens.input ?? 0;
-    const outputTokens = parsed.tokens.output ?? 0;
-    const reasoningTokens = parsed.tokens.reasoning ?? 0;
-    const cacheReadTokens = parsed.tokens.cache?.read ?? 0;
-    const cacheWriteTokens = parsed.tokens.cache?.write ?? 0;
-    if (inputTokens === 0 && outputTokens === 0 && reasoningTokens === 0 && cacheReadTokens === 0 && cacheWriteTokens === 0) continue;
-    const model = parsed.modelID ?? "unknown";
-    const provider = parsed.providerID ?? inferProvider(model);
-    const ts = parsed.time?.created ?? message.time_created;
-    const recordId = generateRecordId(deviceInstanceId, dbPath + ":" + message.id, message.time_created);
-    const tokenArgs = { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, thinkingTokens: reasoningTokens };
-    const calculatedCost = model !== "unknown" ? calculateCost(model, tokenArgs) : 0;
-    const logCostValid = parsed.cost != null && parsed.cost > 0;
-    const cost = logCostValid ? parsed.cost : calculatedCost;
-    const costSource = logCostValid ? "log" : calculatedCost > 0 ? "pricing" : "unknown";
-    const record = {
-      id: recordId,
-      ts,
-      ingestedAt: now,
-      updatedAt: now,
-      lineOffset: 0,
-      // DB-sourced records have no byte offset; use 0 as sentinel
-      tool: "opencode",
-      model,
-      provider,
-      inputTokens,
-      outputTokens,
-      cacheReadTokens,
-      cacheWriteTokens,
-      thinkingTokens: reasoningTokens,
-      cost,
-      costSource,
-      sessionId: message.session_id,
-      sourceFile: dbPath,
-      device,
-      deviceInstanceId,
-      platform: platform4
-    };
-    records.push(record);
-    const parts = partsStmt.all(message.id);
-    let callIndex = 0;
-    for (const part of parts) {
-      let partParsed;
-      try {
-        partParsed = JSON.parse(part.data);
-      } catch (e) {
-        errors.push(`message ${message.id} part ${part.id}: invalid JSON: ${e instanceof Error ? e.message : e}`);
-        continue;
+      if (url.pathname === "/api/models") {
+        const dr = getDateRangeFilter(range, from, to, "", weekStart);
+        const device = url.searchParams.get("device");
+        const df = getDeviceFilter(device, options?.currentDeviceInstanceId);
+        const tool = url.searchParams.get("tool");
+        const tf = getToolFilter(tool);
+        let total;
+        let rows;
+        if (df.useUnion) {
+          const unionSql = `
+            SELECT model, provider, COUNT(*) AS callCount,
+                   SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS totalTokens
+            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+            GROUP BY model, provider
+            UNION ALL
+            SELECT model, provider, COUNT(*) AS callCount,
+                   SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS totalTokens
+            FROM synced_records WHERE device_instance_id != @currentDeviceId ${dr.where} ${tf.where}
+            GROUP BY model, provider
+          `;
+          const mergedRows = db.prepare(`
+            SELECT model, provider, SUM(callCount) AS callCount, SUM(totalTokens) AS totalTokens
+            FROM (${unionSql})
+            WHERE model != 'unknown'
+            GROUP BY model, provider ORDER BY callCount DESC
+          `).all({ ...dr.params, ...df.params, ...tf.params });
+          total = mergedRows.reduce((s, r) => s + r.callCount, 0) || 1;
+          rows = mergedRows;
+        } else if (device && device !== options?.currentDeviceInstanceId) {
+          rows = db.prepare(`
+            SELECT model, provider,
+                   COUNT(*) AS callCount,
+                   SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS totalTokens
+            FROM synced_records WHERE 1=1 AND model != 'unknown' ${df.where} ${dr.where} ${tf.where}
+            GROUP BY model, provider ORDER BY callCount DESC
+          `).all({ ...df.params, ...dr.params, ...tf.params });
+          total = rows.reduce((s, r) => s + r.callCount, 0) || 1;
+        } else {
+          rows = db.prepare(`
+            SELECT model, provider,
+                   COUNT(*) AS callCount,
+                   SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS totalTokens
+            FROM records WHERE 1=1 AND model != 'unknown' ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+            GROUP BY model, provider ORDER BY callCount DESC
+          `).all({ ...dr.params, ...tf.params });
+          total = rows.reduce((s, r) => s + r.callCount, 0) || 1;
+        }
+        const models = rows.map((r) => ({
+          model: r.model,
+          provider: r.provider,
+          callCount: r.callCount,
+          totalTokens: r.totalTokens,
+          percentage: Math.round(r.callCount / total * 1e3) / 10
+        }));
+        json(res, { models });
+        return;
       }
-      if (partParsed.type === "tool" && partParsed.tool) {
-        toolCalls.push({
-          id: generateToolCallId(recordId, partParsed.tool, part.time_created, callIndex),
-          recordId,
-          name: partParsed.tool,
-          ts: part.time_created,
-          callIndex
+      if (url.pathname === "/api/tool-calls") {
+        const device = url.searchParams.get("device");
+        if (device && device !== options?.currentDeviceInstanceId) {
+          json(res, { toolCalls: [] });
+          return;
+        }
+        const dr = getDateRangeFilter(range, from, to, "r", weekStart);
+        const tool = url.searchParams.get("tool");
+        const tf = getToolFilter(tool, "r");
+        const totalRow = db.prepare(`
+          SELECT COUNT(*) AS total FROM tool_calls tc
+          JOIN records r ON r.id = tc.record_id
+          WHERE 1=1 ${dr.where} ${tf.where}
+        `).get({ ...dr.params, ...tf.params });
+        const total = totalRow.total || 1;
+        const rows = db.prepare(`
+          SELECT tc.name, COUNT(*) AS count
+          FROM tool_calls tc
+          JOIN records r ON r.id = tc.record_id
+          WHERE 1=1 ${dr.where} ${tf.where}
+          GROUP BY tc.name ORDER BY count DESC
+        `).all({ ...dr.params, ...tf.params });
+        const toolCalls = rows.map((r) => ({
+          name: r.name,
+          count: r.count,
+          percentage: Math.round(r.count / total * 1e3) / 10
+        }));
+        json(res, { toolCalls });
+        return;
+      }
+      if (url.pathname === "/api/sessions") {
+        const page = Math.max(1, parseInt(url.searchParams.get("page") || "1", 10));
+        const pageSize = Math.min(100, Math.max(1, parseInt(url.searchParams.get("pageSize") || "50", 10)));
+        const dr = getDateRangeFilter(range, from, to, "", weekStart);
+        const device = url.searchParams.get("device");
+        const df = getDeviceFilter(device, options?.currentDeviceInstanceId);
+        const tool = url.searchParams.get("tool");
+        if (device && !df.localOnly && !df.useUnion) {
+          json(res, {
+            sessions: [],
+            total: 0,
+            page,
+            pageSize
+          });
+          return;
+        }
+        const tf = getToolFilter(tool);
+        const params = { ...dr.params, ...tf.params };
+        const totalRow = db.prepare(`
+          SELECT COUNT(DISTINCT session_id) AS total
+          FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+        `).get(params);
+        const sessions = db.prepare(`
+          SELECT session_id AS sessionId,
+                 tool,
+                 model,
+                 MIN(ts) AS ts,
+                 SUM(input_tokens) AS inputTokens,
+                 SUM(output_tokens) AS outputTokens,
+                 SUM(cache_read_tokens) AS cacheReadTokens,
+                 SUM(cache_write_tokens) AS cacheWriteTokens,
+                 SUM(cost) AS cost
+          FROM records
+          WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+          GROUP BY session_id
+          ORDER BY ts DESC
+          LIMIT @limit OFFSET @offset
+        `).all({ ...params, limit: pageSize, offset: (page - 1) * pageSize });
+        json(res, {
+          sessions,
+          total: totalRow.total,
+          page,
+          pageSize
         });
-        callIndex++;
+        return;
       }
-    }
-  }
-  return { records, toolCalls, nextCursor: records.length > 0 ? lastCursor : null, errors };
-}
-
-// src/commands/parse-hermes.ts
-function runParseHermes(db, options) {
-  const { dbPath, device, deviceInstanceId, platform: platform4, now, cursor } = options;
-  const records = [];
-  const toolCalls = [];
-  const errors = [];
-  let lastCursor = null;
-  const sessions = db.prepare(
-    `SELECT id, model, billing_provider, started_at, ended_at,
-              input_tokens, output_tokens, cache_read_tokens, cache_write_tokens,
-              reasoning_tokens, estimated_cost_usd, actual_cost_usd,
-              COALESCE(ended_at, started_at) AS session_ts
-       FROM sessions
-       WHERE (ended_at IS NOT NULL OR input_tokens > 0 OR output_tokens > 0)
-         AND (COALESCE(ended_at, started_at) > ? OR (COALESCE(ended_at, started_at) = ? AND id > ?))
-       ORDER BY COALESCE(ended_at, started_at), id`
-  ).all(
-    cursor?.lastEndedAt ?? 0,
-    cursor?.lastEndedAt ?? 0,
-    cursor?.lastId ?? ""
-  );
-  const toolCallsStmt = db.prepare(
-    `SELECT id, session_id, tool_calls, timestamp
-     FROM messages
-     WHERE session_id = ? AND tool_calls IS NOT NULL
-     ORDER BY timestamp, id`
-  );
-  for (const session of sessions) {
-    lastCursor = { lastEndedAt: session.session_ts, lastId: session.id };
-    const model = session.model ?? "unknown";
-    const ts = Math.round(session.started_at * 1e3);
-    const rawProvider = session.billing_provider;
-    const provider = rawProvider && rawProvider !== "custom" ? rawProvider : inferProvider(model);
-    const inputTokens = session.input_tokens;
-    const outputTokens = session.output_tokens;
-    const cacheReadTokens = session.cache_read_tokens;
-    const cacheWriteTokens = session.cache_write_tokens;
-    const thinkingTokens = session.reasoning_tokens;
-    const tokenArgs = { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, thinkingTokens };
-    let cost;
-    let costSource;
-    if (session.actual_cost_usd != null && session.actual_cost_usd > 0) {
-      cost = session.actual_cost_usd;
-      costSource = "log";
-    } else if (session.estimated_cost_usd != null && session.estimated_cost_usd > 0) {
-      cost = session.estimated_cost_usd;
-      costSource = "log";
-    } else if (model !== "unknown") {
-      cost = calculateCost(model, tokenArgs);
-      costSource = cost > 0 ? "pricing" : "unknown";
-    } else {
-      cost = 0;
-      costSource = "unknown";
-    }
-    const recordId = generateRecordId(deviceInstanceId, dbPath + ":" + session.id, ts);
-    const record = {
-      id: recordId,
-      ts,
-      ingestedAt: now,
-      updatedAt: now,
-      lineOffset: 0,
-      tool: "hermes",
-      model,
-      provider,
-      inputTokens,
-      outputTokens,
-      cacheReadTokens,
-      cacheWriteTokens,
-      thinkingTokens,
-      cost,
-      costSource,
-      sessionId: session.id,
-      sourceFile: dbPath,
-      device,
-      deviceInstanceId,
-      platform: platform4
-    };
-    records.push(record);
-    const messages = toolCallsStmt.all(session.id);
-    let callIndex = 0;
-    for (const message of messages) {
-      let toolCallList;
-      try {
-        const parsed = JSON.parse(message.tool_calls);
-        if (!Array.isArray(parsed)) {
-          errors.push(`session ${session.id} message ${message.id}: tool_calls payload is not an array`);
-          continue;
+      if (url.pathname === "/api/projects") {
+        const dr = getDateRangeFilter(range, from, to, "", weekStart);
+        const device = url.searchParams.get("device");
+        const df = getDeviceFilter(device, options?.currentDeviceInstanceId);
+        const tool = url.searchParams.get("tool");
+        const tf = getToolFilter(tool);
+        if (df.where && !df.useUnion) {
+          json(res, { projects: [] });
+          return;
+        }
+        const rows = db.prepare(`
+          SELECT source_file, cwd,
+                 COUNT(*) AS sessionCount,
+                 SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS totalTokens,
+                 SUM(cost) AS cost
+          FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+          GROUP BY source_file ORDER BY totalTokens DESC
+        `).all({ ...dr.params, ...tf.params });
+        const projectMap = {};
+        for (const row of rows) {
+          const project = row.cwd ? path2.basename(row.cwd) : extractProject(row.source_file);
+          if (!projectMap[project]) projectMap[project] = { sessions: 0, tokens: 0, cost: 0 };
+          projectMap[project].sessions += row.sessionCount;
+          projectMap[project].tokens += row.totalTokens;
+          projectMap[project].cost += row.cost;
+        }
+        const totalTokens = Object.values(projectMap).reduce((s, p) => s + p.tokens, 0) || 1;
+        const projects = Object.entries(projectMap).map(([name, data]) => ({
+          name,
+          sessions: data.sessions,
+          tokens: data.tokens,
+          cost: data.cost,
+          percentage: Math.round(data.tokens / totalTokens * 1e3) / 10
+        })).sort((a, b) => b.tokens - a.tokens);
+        json(res, { projects });
+        return;
+      }
+      if (url.pathname === "/api/pricing") {
+        if (req.method === "GET") {
+          const table = getPriceTable();
+          const overrides = getUserOverrides();
+          const dbModels = db.prepare("SELECT DISTINCT model FROM records WHERE model != 'unknown' ORDER BY model").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 });
+          return;
+        }
+        if (req.method === "PUT") {
+          let body = "";
+          for await (const chunk of req) body += chunk;
+          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);
+            json(res, { ok: true });
+          } catch {
+            json(res, { error: { code: "INVALID_JSON", message: "Invalid JSON body" } }, 400);
+          }
+          return;
+        }
+        if (req.method === "DELETE") {
+          const model = url.searchParams.get("model");
+          if (!model) {
+            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);
+          }
+          json(res, { ok: true });
+          return;
         }
-        toolCallList = parsed;
-      } catch (e) {
-        errors.push(`session ${session.id} message ${message.id}: invalid tool_calls JSON: ${e instanceof Error ? e.message : e}`);
-        continue;
-      }
-      for (const tc of toolCallList) {
-        const name = tc.function?.name;
-        if (!name) continue;
-        toolCalls.push({
-          id: generateToolCallId(recordId, name, Math.round(message.timestamp * 1e3), callIndex),
-          recordId,
-          name,
-          ts: Math.round(message.timestamp * 1e3),
-          callIndex
-        });
-        callIndex++;
       }
-    }
-  }
-  return { records, toolCalls, nextCursor: lastCursor, errors };
-}
-
-// src/commands/parse.ts
-function findJsonlFiles(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(...findJsonlFiles(fullPath));
-      } else if (entry.isFile() && extname(entry.name) === ".jsonl") {
-        results.push(fullPath);
+      if (url.pathname === "/api/pricing/recalc" && req.method === "POST") {
+        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;
+        }
+        json(res, { updated });
+        return;
       }
-    }
-  } catch {
-  }
-  return results;
-}
-function defaultOpenCodeDbPath() {
-  const home = homedir2();
-  const plat = platform2();
-  if (plat === "win32") {
-    const appData = process.env.APPDATA ?? join3(home, "AppData", "Roaming");
-    return join3(appData, "opencode", "opencode.db");
-  }
-  if (plat === "darwin") {
-    return join3(home, "Library", "Application Support", "opencode", "opencode.db");
-  }
-  const xdgDataHome = process.env.XDG_DATA_HOME ?? join3(home, ".local", "share");
-  return join3(xdgDataHome, "opencode", "opencode.db");
-}
-function defaultHermesDbPath() {
-  return join3(homedir2(), ".hermes", "state.db");
-}
-function discoverLogFiles(sources) {
-  const home = homedir2();
-  const results = [];
-  const claudeDir = sources?.["claude-code"] ?? join3(home, ".claude", "projects");
-  if (existsSync4(claudeDir)) {
-    const claudePaths = findJsonlFiles(claudeDir);
-    if (claudePaths.length > 0) {
-      results.push({ tool: "claude-code", paths: claudePaths });
-    }
-  }
-  const codexDir = sources?.["codex"] ?? join3(home, ".codex", "sessions");
-  if (existsSync4(codexDir)) {
-    const codexPaths = findJsonlFiles(codexDir);
-    if (codexPaths.length > 0) {
-      results.push({ tool: "codex", paths: codexPaths });
-    }
-  }
-  const openclawBase = sources?.["openclaw"] ?? join3(home, ".openclaw", "agents");
-  if (existsSync4(openclawBase)) {
-    let openclawPaths;
-    if (sources?.["openclaw"]) {
-      openclawPaths = findJsonlFiles(openclawBase).filter((p) => !p.includes(".checkpoint."));
-    } else {
-      openclawPaths = [];
-      try {
-        const agentEntries = readdirSync(openclawBase, { withFileTypes: true });
-        for (const agentEntry of agentEntries) {
-          if (!agentEntry.isDirectory()) continue;
-          const sessionsDir = join3(openclawBase, agentEntry.name, "sessions");
-          if (existsSync4(sessionsDir)) {
-            openclawPaths.push(...findJsonlFiles(sessionsDir).filter((p) => !p.includes(".checkpoint.")));
+      if (url.pathname === "/api/sync") {
+        if (req.method === "POST") {
+          if (!options?.onSyncStart) {
+            json(res, { error: { code: "NOT_AVAILABLE", message: "Sync not configured" } }, 501);
+            return;
           }
+          const result = options.onSyncStart();
+          json(res, result, result.accepted ? 202 : 200);
+          return;
         }
-      } catch {
+        const status = options?.getSyncStatus?.() ?? null;
+        json(res, { status });
+        return;
       }
-    }
-    if (openclawPaths.length > 0) {
-      results.push({ tool: "openclaw", paths: openclawPaths });
-    }
-  }
-  return results;
-}
-function extractSessionId(filePath, tool) {
-  if (tool === "claude-code") {
-    const parts = filePath.split("/");
-    const filename = parts[parts.length - 1];
-    return filename.replace(".jsonl", "");
-  }
-  if (tool === "codex") {
-    const filename = filePath.split("/").pop() ?? "";
-    const match = filename.match(/rollout-(.+)\.jsonl$/);
-    return match ? match[1] : filename.replace(".jsonl", "");
-  }
-  if (tool === "openclaw") {
-    const filename = filePath.split("/").pop() ?? "";
-    return filename.replace(".jsonl", "");
-  }
-  return "unknown";
-}
-async function runParse(db, filterTool, options) {
-  const state = getState(AIUSAGE_DIR);
-  const config = loadConfig();
-  const device = config?.device || hostname2() || state?.deviceInstanceId?.slice(0, 8) || "unknown";
-  const deviceInstanceId = state?.deviceInstanceId ?? "unknown";
-  const devicePlatform = config?.platform;
-  const watermarkPath = join3(AIUSAGE_DIR, "watermark.json");
-  const wm = new WatermarkManager(watermarkPath);
-  const toolPaths = discoverLogFiles(config?.sources);
-  const aggregator = new Aggregator();
-  let parsedCount = 0;
-  let toolCallCount = 0;
-  const errors = [];
-  for (const { tool, paths } of toolPaths) {
-    if (filterTool && tool !== filterTool) continue;
-    for (const filePath of paths) {
-      try {
-        const stat2 = statSync(filePath);
-        const entry = wm.getEntry(tool, filePath);
-        const offset = entry?.offset ?? 0;
-        if (offset >= stat2.size) continue;
-        const content = readFileSync4(filePath, "utf-8");
-        const lines = content.split("\n");
-        let byteOffset = 0;
-        const sessionId = extractSessionId(filePath, tool);
-        for (const line of lines) {
-          if (!line.trim()) {
-            byteOffset += Buffer.byteLength(line, "utf-8") + 1;
-            continue;
-          }
-          if (byteOffset < offset) {
-            byteOffset += Buffer.byteLength(line, "utf-8") + 1;
-            continue;
+      if (url.pathname === "/api/refresh") {
+        if (!options?.onRefresh) {
+          json(res, { error: { code: "NOT_AVAILABLE", message: "Refresh not available" } }, 501);
+          return;
+        }
+        const result = await options.onRefresh();
+        json(res, result);
+        return;
+      }
+      if (url.pathname === "/api/devices") {
+        let getDisplayName2 = function(device, deviceInstanceId) {
+          if (deviceInstanceId === currentId) return currentDeviceAlias;
+          if (device && device !== "unknown" && !/^[0-9a-f]{8}$/.test(device)) return device;
+          if (/^[0-9a-f]{8}-/.test(deviceInstanceId)) return deviceInstanceId.slice(0, 8);
+          if (device && device !== "unknown") return device;
+          return "Unknown Device";
+        }, getPlatformLabel2 = function(p) {
+          if (p === "win32") return "Windows";
+          if (p === "darwin") return "macOS";
+          if (p === "linux") return "Linux";
+          return "";
+        }, inferPlatform2 = function(device, deviceInstanceId) {
+          const name = (device || "").toLowerCase();
+          const id = (deviceInstanceId || "").toLowerCase();
+          if (/^(desktop|laptop)-/.test(name)) return "Windows";
+          if (name.endsWith(".local") || /macbook|imac|mac\s*mini|mac\s*pro|mac\s*studio/.test(name)) return "macOS";
+          if (/^(ubuntu|debian|centos|fedora|arch|linux|server|node|prod|dev|staging)/.test(name)) return "Linux";
+          return "";
+        };
+        var getDisplayName = getDisplayName2, getPlatformLabel = getPlatformLabel2, inferPlatform = inferPlatform2;
+        const currentId = options?.currentDeviceInstanceId;
+        if (!currentId) {
+          json(res, { currentDeviceInstanceId: null, devices: [] });
+          return;
+        }
+        const config = loadConfig();
+        const currentDeviceAlias = config?.device || hostname2();
+        const localRows = db.prepare(`
+          SELECT device, device_instance_id AS deviceInstanceId, COUNT(*) AS recordCount
+          FROM records
+          WHERE device_instance_id = @currentId AND source_file NOT LIKE 'synced/%'
+          GROUP BY device_instance_id
+        `).all({ currentId });
+        const syncedRows = db.prepare(`
+          SELECT device, device_instance_id AS deviceInstanceId, platform, COUNT(*) AS recordCount
+          FROM synced_records
+          WHERE device_instance_id != @currentId
+          GROUP BY device_instance_id
+        `).all({ currentId });
+        const currentPlatform = config?.platform || platform2();
+        const deviceMap = /* @__PURE__ */ new Map();
+        for (const row of localRows) {
+          const displayName = getDisplayName2(row.device, row.deviceInstanceId);
+          deviceMap.set(row.deviceInstanceId, { device: row.device, deviceInstanceId: row.deviceInstanceId, displayName, platform: getPlatformLabel2(currentPlatform), recordCount: row.recordCount });
+        }
+        for (const row of syncedRows) {
+          const displayName = getDisplayName2(row.device, row.deviceInstanceId);
+          const platformLabel = getPlatformLabel2(row.platform) || inferPlatform2(row.device, row.deviceInstanceId);
+          const existing = deviceMap.get(row.deviceInstanceId);
+          if (existing) {
+            existing.recordCount += row.recordCount;
+          } else {
+            deviceMap.set(row.deviceInstanceId, { device: row.device, deviceInstanceId: row.deviceInstanceId, displayName, platform: platformLabel, recordCount: row.recordCount });
           }
-          const context = aggregator.createContext({
-            tool,
-            sourceFile: filePath,
-            lineOffset: byteOffset,
-            sessionId,
-            device,
-            deviceInstanceId,
-            platform: devicePlatform
+        }
+        const devices = [...deviceMap.values()].sort((a, b) => b.recordCount - a.recordCount);
+        json(res, { currentDeviceInstanceId: currentId, devices });
+        return;
+      }
+      if (url.pathname === "/api/config/credential" && req.method === "GET") {
+        const ref = url.searchParams.get("ref")?.trim();
+        if (!ref) {
+          json(res, { error: { code: "MISSING_CREDENTIAL_REF", message: "credential ref is required" } }, 400);
+          return;
+        }
+        const value = loadCredential(ref);
+        if (!value) {
+          json(res, { error: { code: "CREDENTIAL_NOT_FOUND", message: "Credential not found" } }, 404);
+          return;
+        }
+        json(res, { value });
+        return;
+      }
+      if (url.pathname === "/api/config") {
+        if (req.method === "GET") {
+          const currentCfg = loadConfig() ?? {};
+          const osPlatform = platform2();
+          const { credentials, priceOverrides, platform: _cfgPlatform, ...rest } = currentCfg;
+          json(res, {
+            device: rest.device ?? null,
+            weekStart: rest.weekStart ?? 1,
+            dashboardPollInterval: rest.dashboardPollInterval ?? null,
+            parseInterval: rest.parseInterval ?? null,
+            retentionDays: rest.retentionDays ?? null,
+            sources: {
+              "claude-code": rest.sources?.["claude-code"] ?? null,
+              codex: rest.sources?.codex ?? null,
+              openclaw: rest.sources?.openclaw ?? null,
+              opencode: rest.sources?.opencode ?? null,
+              hermes: rest.sources?.hermes ?? null,
+              qoder: rest.sources?.qoder ?? null,
+              "qoder-db": rest.sources?.["qoder-db"] ?? null
+            },
+            sync: rest.sync ?? null,
+            displayCurrency: rest.displayCurrency ?? "USD",
+            exchangeRate: rest.exchangeRate ?? null,
+            exchangeRateCache: rest.exchangeRateCache ?? null,
+            credentialKeys: credentials ? Object.keys(credentials) : [],
+            hostname: hostname2(),
+            platform: osPlatform,
+            defaultPaths: getDefaultSourcePaths()
           });
-          const result = aggregator.parseLine(line, context);
-          if (result) {
-            if (result.record) {
-              insertRecord(db, result.record);
-              parsedCount++;
+          return;
+        }
+        if (req.method === "PUT") {
+          let body = "";
+          for await (const chunk of req) body += chunk;
+          try {
+            const update = JSON.parse(body);
+            const existing = loadConfig() ?? {};
+            if ("device" in update) {
+              if (!update.device) delete existing.device;
+              else existing.device = String(update.device);
             }
-            for (const tc of result.toolCalls) {
-              insertToolCall(db, tc);
-              toolCallCount++;
+            if ("weekStart" in update) {
+              const ws = Number(update.weekStart);
+              if (ws === 0 || ws === 1) {
+                existing.weekStart = ws;
+                weekStart = ws;
+              } else {
+                delete existing.weekStart;
+              }
             }
+            if ("displayCurrency" in update) {
+              const dc = update.displayCurrency;
+              if (dc === "USD" || dc === "CNY") {
+                existing.displayCurrency = dc;
+              } else {
+                delete existing.displayCurrency;
+              }
+            }
+            if ("exchangeRate" in update) {
+              const er = update.exchangeRate;
+              if (er != null && typeof er === "number" && er > 0) {
+                existing.exchangeRate = er;
+              } else {
+                delete existing.exchangeRate;
+              }
+            }
+            if ("dashboardPollInterval" in update) {
+              if (!update.dashboardPollInterval) delete existing.dashboardPollInterval;
+              else existing.dashboardPollInterval = Number(update.dashboardPollInterval);
+            }
+            if ("parseInterval" in update) {
+              if (!update.parseInterval) delete existing.parseInterval;
+              else existing.parseInterval = Number(update.parseInterval);
+            }
+            if ("retentionDays" in update) {
+              if (!update.retentionDays) delete existing.retentionDays;
+              else existing.retentionDays = Number(update.retentionDays);
+            }
+            if (update.sources && typeof update.sources === "object") {
+              const src = update.sources;
+              const s = existing.sources ?? {};
+              for (const key of ["claude-code", "codex", "openclaw", "opencode", "hermes", "qoder", "qoder-db"]) {
+                if (key in src) {
+                  if (!src[key]) delete s[key];
+                  else s[key] = String(src[key]);
+                }
+              }
+              if (Object.keys(s).length) existing.sources = s;
+              else delete existing.sources;
+            }
+            if ("sync" in update) {
+              const syncUpdate = update.sync;
+              if (!syncUpdate?.backend) {
+                delete existing.sync;
+              } else {
+                const backendVal = String(syncUpdate.backend);
+                if (backendVal !== "github" && backendVal !== "s3") {
+                  json(res, { error: { code: "INVALID_BACKEND", message: "sync.backend must be github or s3" } }, 400);
+                  return;
+                }
+                const newSync = { backend: backendVal };
+                for (const f of ["repo", "bucket", "prefix", "endpoint", "region", "credentialRef"]) {
+                  if (syncUpdate[f]) newSync[f] = String(syncUpdate[f]);
+                }
+                existing.sync = newSync;
+              }
+            }
+            if (update.credentials && typeof update.credentials === "object") {
+              const creds = update.credentials;
+              const c = existing.credentials ?? {};
+              for (const [key, val] of Object.entries(creds)) {
+                if (val !== "" && val !== null && val !== void 0) {
+                  c[key] = String(val);
+                }
+              }
+              if (Object.keys(c).length) existing.credentials = c;
+              else delete existing.credentials;
+            }
+            saveConfig(existing);
+            options?.onConfigUpdated?.();
+            json(res, { ok: true });
+          } catch {
+            json(res, { error: { code: "INVALID_JSON", message: "Invalid JSON body" } }, 400);
           }
-          byteOffset += Buffer.byteLength(line, "utf-8") + 1;
-        }
-        const orphanResults = aggregator.finalize();
-        for (const result of orphanResults) {
-          for (const tc of result.toolCalls) {
-            insertToolCall(db, tc);
-            toolCallCount++;
-          }
-        }
-        wm.setEntry(tool, filePath, {
-          offset: stat2.size,
-          size: stat2.size,
-          mtime: stat2.mtimeMs
-        });
-        wm.save();
-      } catch (e) {
-        errors.push(`${filePath}: ${e instanceof Error ? e.message : e}`);
-      }
-    }
-  }
-  const openCodeDbPath = options?.openCodeDbPath ?? config?.sources?.["opencode"] ?? defaultOpenCodeDbPath();
-  if ((!filterTool || filterTool === "opencode") && existsSync4(openCodeDbPath)) {
-    try {
-      const openCodeDb = new Database(openCodeDbPath, { readonly: true });
-      try {
-        const result = runParseOpenCode(openCodeDb, {
-          dbPath: openCodeDbPath,
-          device,
-          deviceInstanceId,
-          platform: devicePlatform,
-          now: Date.now(),
-          cursor: wm.getOpenCodeCursor()
-        });
-        for (const record of result.records) insertRecord(db, record);
-        for (const tc of result.toolCalls) insertToolCall(db, tc);
-        if (result.nextCursor) {
-          wm.setOpenCodeCursor(result.nextCursor);
-          wm.save();
+          return;
         }
-        parsedCount += result.records.length;
-        toolCallCount += result.toolCalls.length;
-        errors.push(...result.errors);
-      } finally {
-        openCodeDb.close();
       }
-    } catch (e) {
-      errors.push(`${openCodeDbPath}: ${e instanceof Error ? e.message : e}`);
-    }
-  }
-  const hermesDbPath = options?.hermesDbPath ?? config?.sources?.["hermes"] ?? defaultHermesDbPath();
-  if ((!filterTool || filterTool === "hermes") && existsSync4(hermesDbPath)) {
-    try {
-      const hermesDb = new Database(hermesDbPath, { readonly: true });
-      try {
-        const result = runParseHermes(hermesDb, {
-          dbPath: hermesDbPath,
-          device,
-          deviceInstanceId,
-          platform: devicePlatform,
-          now: Date.now(),
-          cursor: wm.getHermesCursor()
-        });
-        for (const record of result.records) insertRecord(db, record);
-        for (const tc of result.toolCalls) insertToolCall(db, tc);
-        if (result.nextCursor) {
-          wm.setHermesCursor(result.nextCursor);
-          wm.save();
+      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;
         }
-        parsedCount += result.records.length;
-        toolCallCount += result.toolCalls.length;
-        errors.push(...result.errors);
-      } finally {
-        hermesDb.close();
+        const cfg2 = loadConfig() ?? {};
+        cfg2.exchangeRateCache = { CNY_USD: rate, fetchedAt: Date.now() };
+        saveConfig(cfg2);
+        json(res, { rate, fetchedAt: cfg2.exchangeRateCache.fetchedAt });
+        return;
       }
-    } catch (e) {
-      errors.push(`${hermesDbPath}: ${e instanceof Error ? e.message : e}`);
+      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);
     }
-  }
-  if (deviceInstanceId !== "unknown") {
-    db.prepare(
-      `UPDATE records SET device_instance_id = ?, device = ? WHERE device_instance_id = 'unknown'`
-    ).run(deviceInstanceId, device);
-  }
-  if (devicePlatform) {
-    db.prepare(
-      `UPDATE records SET platform = ? WHERE platform = '' AND source_file NOT LIKE 'synced/%'`
-    ).run(devicePlatform);
-  }
-  return { parsedCount, toolCallCount, errors };
+  });
+  return server;
 }
 
 // src/commands/sync.ts
@@ -1815,15 +2803,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 {
@@ -1841,7 +2829,7 @@ var SyncOrchestrator = class {
       }
       this.options.onProgress?.({
         phase: "pulling",
-        currentPath: path2,
+        currentPath: path3,
         completedFiles: index + 1,
         totalFiles: paths.length,
         pulledCount: totalPulled
@@ -1849,13 +2837,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() {
@@ -1863,9 +2851,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());
@@ -1875,20 +2863,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);
-      const changedCount = await this.uploadFile(path2, localSyncRecords);
+      const changedCount = await this.uploadFile(path3, localSyncRecords);
       totalUploaded += changedCount;
       this.options.onProgress?.({
         phase: "uploading",
-        currentPath: path2,
+        currentPath: path3,
         completedFiles: index + 1,
         totalFiles: uploads.length,
         uploadedCount: totalUploaded
@@ -1905,7 +2893,7 @@ var SyncOrchestrator = class {
 };
 
 // src/sync/consent.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 function generateConsentFingerprint(config) {
   const input = [
     config.backend,
@@ -1916,7 +2904,7 @@ function generateConsentFingerprint(config) {
     config.operations.join(","),
     config.schemaVersion
   ].join("|");
-  return createHash("sha256").update(input).digest("hex").slice(0, 16);
+  return createHash2("sha256").update(input).digest("hex").slice(0, 16);
 }
 function verifyConsent(storedFingerprint, currentConfig) {
   const currentFingerprint = generateConsentFingerprint(currentConfig);
@@ -1986,16 +2974,16 @@ var GitSyncBackend = class _GitSyncBackend {
       }
     }
   }
-  async readFile(path2) {
+  async readFile(path3) {
     try {
-      const fullPath = join4(this.dataDir, path2);
+      const fullPath = join4(this.dataDir, path3);
       return await readFile(fullPath, "utf-8");
     } catch {
       return null;
     }
   }
-  async writeFile(path2, content) {
-    const fullPath = join4(this.dataDir, path2);
+  async writeFile(path3, content) {
+    const fullPath = join4(this.dataDir, path3);
     await mkdir(join4(fullPath, ".."), { recursive: true });
     await writeFile(fullPath, content, "utf-8");
   }
@@ -2057,11 +3045,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,
@@ -2077,8 +3065,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,
@@ -2110,8 +3098,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,
@@ -2379,6 +3367,19 @@ function serve(options) {
       setPriceOverride(model, entry);
     }
   }
+  if (config == null || config.exchangeRate == null) {
+    const cacheAge = config?.exchangeRateCache ? Date.now() - config.exchangeRateCache.fetchedAt : Infinity;
+    if (cacheAge >= CACHE_TTL_MS) {
+      fetchExchangeRate().then((rate) => {
+        if (rate != null) {
+          const cfg = loadConfig() ?? {};
+          cfg.exchangeRateCache = { CNY_USD: rate, fetchedAt: Date.now() };
+          saveConfig(cfg);
+        }
+      }).catch(() => {
+      });
+    }
+  }
   const syncRuntime = new SyncRuntimeController({
     runSync: (runtimeOptions) => runSync(options.db, runtimeOptions).then(() => void 0),
     getPersistedState: () => getState(AIUSAGE_DIR)
@@ -2478,9 +3479,9 @@ function runInit(options) {
     const config = {
       device: options.device ?? existingConfig?.device,
       platform: existingConfig?.platform ?? platform3(),
-      retentionDays: existingConfig?.retentionDays ?? 180,
-      parseInterval: existingConfig?.parseInterval ?? 60,
-      dashboardPollInterval: existingConfig?.dashboardPollInterval ?? 30,
+      retentionDays: existingConfig?.retentionDays,
+      parseInterval: existingConfig?.parseInterval,
+      dashboardPollInterval: existingConfig?.dashboardPollInterval,
       credentials: existingConfig?.credentials
     };
     saveConfig(config);
@@ -2501,9 +3502,9 @@ function runInit(options) {
       },
       device: options.device ?? existingConfig?.device,
       platform: existingConfig?.platform ?? platform3(),
-      retentionDays: existingConfig?.retentionDays ?? 180,
-      parseInterval: existingConfig?.parseInterval ?? 60,
-      dashboardPollInterval: existingConfig?.dashboardPollInterval ?? 30,
+      retentionDays: existingConfig?.retentionDays,
+      parseInterval: existingConfig?.parseInterval,
+      dashboardPollInterval: existingConfig?.dashboardPollInterval,
       credentials: {
         ...existingConfig?.credentials,
         [`github/${options.repo}/token`]: options.token
@@ -2547,9 +3548,9 @@ Consent recorded for schema v1.`
       },
       device: options.device ?? existingConfig?.device,
       platform: existingConfig?.platform ?? platform3(),
-      retentionDays: existingConfig?.retentionDays ?? 180,
-      parseInterval: existingConfig?.parseInterval ?? 60,
-      dashboardPollInterval: existingConfig?.dashboardPollInterval ?? 30,
+      retentionDays: existingConfig?.retentionDays,
+      parseInterval: existingConfig?.parseInterval,
+      dashboardPollInterval: existingConfig?.dashboardPollInterval,
       credentials: {
         ...existingConfig?.credentials,
         [`s3/${options.bucket}/accessKeyId`]: options.accessKeyId,
@@ -2672,6 +3673,7 @@ function generateSummary(db, options) {
 
 // src/commands/status.ts
 import { statSync as statSync3, existsSync as existsSync6 } from "fs";
+import { hostname as hostname3 } from "os";
 import { join as join7 } from "path";
 function formatFileSize(bytes) {
   if (bytes < 1024) return `${bytes} B`;
@@ -2699,9 +3701,11 @@ function generateStatus(db) {
     } catch {
     }
   }
+  const config = loadConfig();
+  const deviceName = config?.device || hostname3() || state?.deviceInstanceId?.slice(0, 8) || "unknown";
   return {
     version: "0.0.1",
-    deviceName: state?.deviceInstanceId?.slice(0, 8) ?? "unknown",
+    deviceName,
     dbPath,
     databaseSize,
     schemaVersion,
@@ -2764,32 +3768,58 @@ function exportData(db, format) {
   return lines.join("\n");
 }
 
+// src/commands/reset.ts
+import { unlinkSync, existsSync as existsSync7 } from "fs";
+import { join as join8 } 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 = join8(AIUSAGE_DIR, "watermark.json");
+  let watermarkRemoved = false;
+  if (existsSync7(watermarkPath)) {
+    unlinkSync(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) {
   let updatedCount = 0;
   let skippedCount = 0;
   let lastId = "";
-  const updateStmt = db.prepare("UPDATE records SET cost = ?, updated_at = ? WHERE id = ?");
+  const exchangeRate = resolveExchangeRate(loadConfig() ?? {});
+  const updateStmt = db.prepare("UPDATE records SET model = ?, provider = ?, cost = ?, cost_source = ?, updated_at = ? WHERE id = ?");
   while (true) {
     const records = db.prepare(
-      "SELECT id, model, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens, cost, cost_source FROM records WHERE id > ? ORDER BY id LIMIT ?"
+      "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_SIZE);
     if (records.length === 0) break;
     for (const record of records) {
-      if (record.cost_source !== "pricing") {
+      if (record.cost_source === "log") {
         skippedCount++;
         continue;
       }
-      const newCost = calculateCost(record.model, {
+      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, {
         inputTokens: record.input_tokens,
         outputTokens: record.output_tokens,
         cacheReadTokens: record.cache_read_tokens,
         cacheWriteTokens: record.cache_write_tokens,
         thinkingTokens: record.thinking_tokens
-      });
-      if (newCost !== record.cost) {
-        updateStmt.run(newCost, Date.now(), record.id);
+      }, exchangeRate) : 0;
+      const costSource = hasPrice ? "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++;
       }
     }
@@ -2798,6 +3828,36 @@ function recalcPricing(db) {
   return { updatedCount, skippedCount };
 }
 
+// src/progress.ts
+var MIN_INTERVAL_MS = 100;
+var isTTY = process.stderr.isTTY === true;
+function formatBar(ratio, width = 20) {
+  const filled = Math.round(ratio * width);
+  return "[" + "\u2588".repeat(filled) + "\u2591".repeat(width - filled) + "]";
+}
+var ProgressReporter = class {
+  lastWrite = 0;
+  lastLine = "";
+  update(info) {
+    if (!isTTY) return;
+    const now = Date.now();
+    if (now - this.lastWrite < MIN_INTERVAL_MS) return;
+    this.lastWrite = now;
+    const pct = info.total > 0 ? info.current / info.total * 100 : 0;
+    const bar = formatBar(info.total > 0 ? info.current / info.total : 0);
+    const toolLabel = info.tool ? ` [${info.tool}]` : "";
+    const line = `\r${info.phase}${toolLabel} ${bar} ${pct.toFixed(1)}%  ${info.current}/${info.total}  records: ${info.records}  calls: ${info.toolCalls}  `;
+    if (line !== this.lastLine) {
+      process.stderr.write(line);
+      this.lastLine = line;
+    }
+  }
+  done() {
+    if (!isTTY) return;
+    process.stderr.write("\r\x1B[K");
+  }
+};
+
 // src/db/index.ts
 import Database2 from "better-sqlite3";
 import { mkdirSync as mkdirSync2 } from "fs";
@@ -3001,12 +4061,22 @@ function migrateV4(db) {
   db.prepare("INSERT INTO schema_version (version) VALUES (4)").run();
 }
 
+// src/db/migrations/v5.ts
+function migrateV5(db) {
+  const columns = db.prepare("PRAGMA table_info('records')").all();
+  if (!columns.some((c) => c.name === "cwd")) {
+    db.exec(`ALTER TABLE records ADD COLUMN cwd TEXT NOT NULL DEFAULT ''`);
+  }
+  db.prepare("INSERT INTO schema_version (version) VALUES (5)").run();
+}
+
 // src/db/migrations/index.ts
 var MIGRATIONS = [
   { version: 1, migrate: migrateV1 },
   { version: 2, migrate: migrateV2 },
   { version: 3, migrate: migrateV3 },
-  { version: 4, migrate: migrateV4 }
+  { version: 4, migrate: migrateV4 },
+  { version: 5, migrate: migrateV5 }
 ];
 function runMigrations(db) {
   createSchemaVersionTable(db);
@@ -3028,18 +4098,18 @@ function initializeDatabase(db) {
   applyPragmas(db);
   runMigrations(db);
 }
-function createDatabase(path2) {
-  mkdirSync2(dirname2(path2), { recursive: true, mode: 448 });
-  const db = new Database2(path2);
+function createDatabase(path3) {
+  mkdirSync2(dirname2(path3), { recursive: true, mode: 448 });
+  const db = new Database2(path3);
   initializeDatabase(db);
   return db;
 }
 
 // src/cli.ts
-import { join as join8 } from "path";
-var DB_PATH = join8(AIUSAGE_DIR, "cache.db");
+import { join as join9 } from "path";
+var DB_PATH = join9(AIUSAGE_DIR, "cache.db");
 var program = new Command();
-program.name("aiusage").version(true ? "1.2.1" : "dev").description("CLI tool for AI usage statistics");
+program.name("aiusage").version(true ? "1.3.0" : "dev").description("CLI tool for AI usage statistics");
 program.action(() => {
   const db = createDatabase(DB_PATH);
   const state = getState(AIUSAGE_DIR);
@@ -3066,7 +4136,7 @@ program.action(() => {
   }
   db.close();
 });
-program.command("summary").description("Show usage summary").option("--week", "Show this week").option("--month", "Show this month").option("--from <date>", "Start date (YYYY-MM-DD)").option("--to <date>", "End date (YYYY-MM-DD)").option("--device <id>", "Filter by device instance ID").option("--tool <tool>", "Filter by tool type (claude-code|codex|openclaw|opencode|hermes)").action((options) => {
+program.command("summary").description("Show usage summary").option("--week", "Show this week").option("--month", "Show this month").option("--from <date>", "Start date (YYYY-MM-DD)").option("--to <date>", "End date (YYYY-MM-DD)").option("--device <id>", "Filter by device instance ID").option("--tool <tool>", "Filter by tool type (claude-code|codex|openclaw|opencode|hermes|qoder)").action((options) => {
   const db = createDatabase(DB_PATH);
   const state = getState(AIUSAGE_DIR);
   const summary = generateSummary(db, {
@@ -3122,15 +4192,20 @@ program.command("export").description("Export data").requiredOption("--format <f
   }
   db.close();
 });
-program.command("parse").description("Parse AI tool session logs").option("--tool <tool>", "Specific tool to parse (claude-code|codex|openclaw|opencode|hermes)").action(async (options) => {
+program.command("parse").description("Parse AI tool session logs").option("--tool <tool>", "Specific tool to parse (claude-code|codex|openclaw|opencode|hermes|qoder)").option("--progress", "Show real-time progress").action(async (options) => {
   const db = createDatabase(DB_PATH);
+  const reporter = options.progress ? new ProgressReporter() : void 0;
   try {
-    const result = await runParse(db, options.tool);
+    const result = await runParse(db, options.tool, {
+      onProgress: reporter ? (info) => reporter.update(info) : void 0
+    });
+    reporter?.done();
     console.log(`Parsed ${result.parsedCount} records, ${result.toolCallCount} tool calls.`);
     if (result.errors.length > 0) {
       console.warn(`${result.errors.length} errors encountered.`);
     }
   } catch (e) {
+    reporter?.done();
     console.error(`Parse failed: ${e instanceof Error ? e.message : e}`);
     process.exit(1);
   } finally {
@@ -3149,6 +4224,21 @@ program.command("clean").description("Clean old data").option("--before <duratio
   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 (!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);
+  }
+  const db = createDatabase(DB_PATH);
+  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.");
+  }
+  db.close();
+});
 program.command("recalc").description("Recalculate costs").option("--pricing", "Recalculate using latest pricing").action(() => {
   const db = createDatabase(DB_PATH);
   const result = recalcPricing(db);