fix(kilo): fall back to pricing.ts when Kilo records 0 cost with real usage

Kilo doesn't compute cost for every provider/model combo — sessions
routed through local/OpenAI-compatible endpoints (e.g. GLM 5.2 via
Ollama) come back with cost=0 even though real tokens were used. Fall
back to calculateCost() so Ollama-served models still get an
estimated cost, matching how claude-code and codex already work.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: ClaudiaFang

cli/src/providers/__tests__/kilo.test.ts

@@ -395,6 +395,29 @@ describe('KiloProvider', () => {
       expect(session!.usage!.estimatedCostUsd).toBe(0.03);
     });
 
+    it('falls back to pricing.ts when Kilo recorded cost is 0 but tokens are present (e.g. local/OpenAI-compatible providers like Ollama)', async () => {
+      const db = new Database(tempDbPath, { readonly: false });
+      db.prepare(`
+        UPDATE session SET model = ?, cost = 0, tokens_input = ?, tokens_output = ?, tokens_cache_read = 0, tokens_cache_write = 0
+        WHERE id = ?
+      `).run(
+        JSON.stringify({ id: 'glm-5.2', providerID: 'openai-compatible' }),
+        1_000_000, 1_000_000,
+        'db-ses-1',
+      );
+      db.prepare(`UPDATE message SET data = ? WHERE id = ?`).run(
+        JSON.stringify({ role: 'assistant', model: { providerID: 'openai-compatible', modelID: 'glm-5.2' } }),
+        'db-msg-2',
+      );
+      db.close();
+
+      const virtualPath = `${tempDbPath}#db-ses-1`;
+      const session = await provider.parse(virtualPath);
+
+      // input: 1M * $1.4/1M = $1.40, output: 1M * $4.4/1M = $4.40 -> $5.80
+      expect(session!.usage!.estimatedCostUsd).toBe(5.8);
+    });
+
     it('handles reasoning part type in database', async () => {
       const db = new Database(tempDbPath, { readonly: false });
       db.prepare(`

cli/src/providers/kilo.ts

@@ -6,6 +6,7 @@ import type { SessionProvider } from './types.js';
 import type { ParsedSession, ParsedMessage, ToolCall, ToolResult, SessionUsage } from '../types.js';
 import { getKiloDir } from '../utils/config.js';
 import { generateTitle, detectSessionCharacter } from '../parser/titles.js';
+import { calculateCost, type UsageEntry } from '../utils/pricing.js';
 
 /**
  * Kilo session provider.
@@ -289,6 +290,7 @@ export class KiloProvider implements SessionProvider {
     let cacheReadTokens = 0;
     const modelsUsed = new Set<string>();
     let totalCost = 0;
+    const usageEntries: UsageEntry[] = [];
 
     for (const msg of messages) {
       if (msg.usage) {
@@ -297,9 +299,25 @@ export class KiloProvider implements SessionProvider {
         cacheReadTokens += msg.usage.cacheReadTokens;
         totalCost += msg.usage.estimatedCostUsd;
         modelsUsed.add(msg.usage.model);
+        usageEntries.push({
+          model: msg.usage.model,
+          usage: {
+            input_tokens: msg.usage.inputTokens,
+            output_tokens: msg.usage.outputTokens,
+            cache_creation_input_tokens: msg.usage.cacheCreationTokens,
+            cache_read_input_tokens: msg.usage.cacheReadTokens,
+          },
+        });
       }
     }
 
+    // Kilo doesn't record cost for every provider (e.g. local/OpenAI-compatible
+    // endpoints like Ollama) — its own `cost` field comes back 0 even when real
+    // token usage was recorded. Fall back to our own pricing table in that case.
+    if (totalCost === 0 && (totalInputTokens > 0 || totalOutputTokens > 0)) {
+      totalCost = calculateCost(usageEntries);
+    }
+
     const primaryModel = Array.from(modelsUsed)[0] || 'unknown';
 
     return {