diff --git a/desktop/backend/services.go b/desktop/backend/services.go
index b8fd89f..9cf5d31 100644
--- a/desktop/backend/services.go
+++ b/desktop/backend/services.go
@@ -61,6 +61,8 @@ type AntigravityService struct {
 }
 
 type ClaudeCodeService struct {
+	autoSync    *usageAutoSyncRuntime
+	settingsMu  sync.Mutex
 	application *app.Application
 	changes     *ChangeNotifier
 }
@@ -106,24 +108,25 @@ type AgentService struct {
 }
 
 type Services struct {
-	App                *AppService
-	Agent              *AgentService
-	Antigravity        *AntigravityService
-	ClaudeCode         *ClaudeCodeService
-	Codex              *CodexService
-	GrokBuild          *GrokBuildService
-	Profile            *ProfileService
-	Switch             *SwitchService
-	Doctor             *DoctorService
-	Backup             *BackupService
-	Usage              *UsageService
-	Settings           *SettingsService
-	changes            *ChangeNotifier
-	codexUsageSync     *usageAutoSyncRuntime
-	grokBuildUsageSync *usageAutoSyncRuntime
-	quota              *codexQuotaRuntime
-	runtimes           *agentRuntimeManager
-	backups            *applicationBackupRuntime
+	App                 *AppService
+	Agent               *AgentService
+	Antigravity         *AntigravityService
+	ClaudeCode          *ClaudeCodeService
+	Codex               *CodexService
+	GrokBuild           *GrokBuildService
+	Profile             *ProfileService
+	Switch              *SwitchService
+	Doctor              *DoctorService
+	Backup              *BackupService
+	Usage               *UsageService
+	Settings            *SettingsService
+	changes             *ChangeNotifier
+	codexUsageSync      *usageAutoSyncRuntime
+	grokBuildUsageSync  *usageAutoSyncRuntime
+	claudeCodeUsageSync *usageAutoSyncRuntime
+	quota               *codexQuotaRuntime
+	runtimes            *agentRuntimeManager
+	backups             *applicationBackupRuntime
 }
 
 type DashboardResult struct {
@@ -310,6 +313,18 @@ func NewServices(application *app.Application, info app.Info, env Environment, s
 			return application.Usage().SyncProviderBackground(ctx, grokconfig.ProviderID, onWorkDetected)
 		},
 	)
+	claudeCodeUsageSync := newUsageAutoSyncRuntime(
+		claudecodeconfig.ProviderID,
+		func(ctx context.Context) (usage.ProviderSyncSettings, error) {
+			value, err := application.ClaudeCode().GetSettings(ctx)
+			return usage.ProviderSyncSettings{
+				UsageSyncIntervalSeconds: value.UsageSyncIntervalSeconds,
+			}, err
+		},
+		func(ctx context.Context, onWorkDetected func()) (usage.BackgroundSyncOutcome, error) {
+			return application.Usage().SyncProviderBackground(ctx, claudecodeconfig.ProviderID, onWorkDetected)
+		},
+	)
 	quota := newCodexQuotaRuntime(application.Codex().ListAutomationTargets, application.Codex().RunCredentialJob)
 	backups := newApplicationBackupRuntime(
 		application.Settings().Get,
@@ -323,7 +338,7 @@ func NewServices(application *app.Application, info app.Info, env Environment, s
 		App:         &AppService{application: application, info: info, env: env, startupErr: startupErr, changes: changes},
 		Agent:       &AgentService{application: application, changes: changes},
 		Antigravity: &AntigravityService{application: application, changes: changes},
-		ClaudeCode:  &ClaudeCodeService{application: application, changes: changes},
+		ClaudeCode:  &ClaudeCodeService{application: application, changes: changes, autoSync: claudeCodeUsageSync},
 		Codex:       &CodexService{application: application, changes: changes, autoSync: codexUsageSync, quota: quota},
 		GrokBuild:   &GrokBuildService{application: application, changes: changes, autoSync: grokBuildUsageSync},
 		Profile:     &ProfileService{application: application, changes: changes, quota: quota},
@@ -333,20 +348,23 @@ func NewServices(application *app.Application, info app.Info, env Environment, s
 		Usage: &UsageService{
 			application: application,
 			autoSync: map[string]*usageAutoSyncRuntime{
-				codexconfig.ProviderID: codexUsageSync,
-				grokconfig.ProviderID:  grokBuildUsageSync,
+				codexconfig.ProviderID:      codexUsageSync,
+				grokconfig.ProviderID:       grokBuildUsageSync,
+				claudecodeconfig.ProviderID: claudeCodeUsageSync,
 			},
 		},
-		Settings:           &SettingsService{application: application},
-		changes:            changes,
-		codexUsageSync:     codexUsageSync,
-		grokBuildUsageSync: grokBuildUsageSync,
-		quota:              quota,
-		runtimes:           runtimes,
-		backups:            backups,
+		Settings:            &SettingsService{application: application},
+		changes:             changes,
+		codexUsageSync:      codexUsageSync,
+		grokBuildUsageSync:  grokBuildUsageSync,
+		claudeCodeUsageSync: claudeCodeUsageSync,
+		quota:               quota,
+		runtimes:            runtimes,
+		backups:             backups,
 	}
 	runtimes.Register(agent.Codex, codexUsageSync)
 	runtimes.Register(agent.GrokBuild, grokBuildUsageSync)
+	runtimes.Register(agent.ClaudeCode, claudeCodeUsageSync)
 	runtimes.Register(agent.Codex, quota)
 	return services
 }
@@ -358,13 +376,16 @@ func (s Services) SubscribeChanges(listener func(DesktopChangeEvent)) func() {
 func (s Services) StartUsageAutoSync(ctx context.Context, emitter func(UsageAutoSyncStatus)) {
 	s.codexUsageSync.SetEmitter(emitter)
 	s.grokBuildUsageSync.SetEmitter(emitter)
+	s.claudeCodeUsageSync.SetEmitter(emitter)
 	s.runtimes.Activate(ctx, agent.Codex, s.codexUsageSync)
 	s.runtimes.Activate(ctx, agent.GrokBuild, s.grokBuildUsageSync)
+	s.runtimes.Activate(ctx, agent.ClaudeCode, s.claudeCodeUsageSync)
 }
 
 func (s Services) StopUsageAutoSync() {
 	s.runtimes.Deactivate(agent.Codex, s.codexUsageSync)
 	s.runtimes.Deactivate(agent.GrokBuild, s.grokBuildUsageSync)
+	s.runtimes.Deactivate(agent.ClaudeCode, s.claudeCodeUsageSync)
 }
 
 func (s Services) StartCodexQuotaRuntime(ctx context.Context, emitter func(CodexQuotaRuntimeStatus)) {
@@ -1349,3 +1370,25 @@ func FormatDesktopErrorPtr(err error) *DesktopError {
 	payload := FormatDesktopError(err)
 	return &payload
 }
+
+func (s *ClaudeCodeService) GetSettings(ctx context.Context) (claudecode.Settings, error) {
+	return s.application.ClaudeCode().GetSettings(ctx)
+}
+
+func (s *ClaudeCodeService) UpdateSettings(
+	ctx context.Context,
+	req claudecode.UpdateSettingsRequest,
+) (claudecode.Settings, error) {
+	// Persist and update only this Provider's runtime under one serial order so
+	// a slower older request cannot restore a stale interval.
+	s.settingsMu.Lock()
+	defer s.settingsMu.Unlock()
+	value, err := s.application.ClaudeCode().UpdateSettings(ctx, req)
+	if err != nil {
+		return claudecode.Settings{}, err
+	}
+	if req.UsageSyncIntervalSeconds != nil {
+		s.autoSync.SetInterval(value.UsageSyncIntervalSeconds)
+	}
+	return value, nil
+}
diff --git a/desktop/frontend/bindings/github.com/strahe/profiledeck/desktop/backend/claudecodeservice.ts b/desktop/frontend/bindings/github.com/strahe/profiledeck/desktop/backend/claudecodeservice.ts
index 681a3ed..09df711 100644
--- a/desktop/frontend/bindings/github.com/strahe/profiledeck/desktop/backend/claudecodeservice.ts
+++ b/desktop/frontend/bindings/github.com/strahe/profiledeck/desktop/backend/claudecodeservice.ts
@@ -25,6 +25,10 @@ export function Detect(): $CancellablePromise<claudecode$0.ClaudeCodeDetectResul
     return $Call.ByID(4104865097);
 }
 
+export function GetSettings(): $CancellablePromise<claudecode$0.Settings> {
+    return $Call.ByID(77725791);
+}
+
 export function ListProfiles(): $CancellablePromise<claudecode$0.ClaudeCodeProfileListResult> {
     return $Call.ByID(2487267564);
 }
@@ -40,3 +44,7 @@ export function ShowProfile(profileID: string): $CancellablePromise<claudecode$0
 export function UpdateProfile(req: $models.UpdateClaudeCodeProfileRequest): $CancellablePromise<claudecode$0.ClaudeCodeProfileDetail> {
     return $Call.ByID(3263369448, req);
 }
+
+export function UpdateSettings(req: claudecode$0.UpdateSettingsRequest): $CancellablePromise<claudecode$0.Settings> {
+    return $Call.ByID(325034858, req);
+}
diff --git a/desktop/frontend/bindings/github.com/strahe/profiledeck/internal/claudecode/index.ts b/desktop/frontend/bindings/github.com/strahe/profiledeck/internal/claudecode/index.ts
index 8118a36..b1ce362 100644
--- a/desktop/frontend/bindings/github.com/strahe/profiledeck/internal/claudecode/index.ts
+++ b/desktop/frontend/bindings/github.com/strahe/profiledeck/internal/claudecode/index.ts
@@ -6,5 +6,7 @@ export type {
     ClaudeCodeProfileDetail,
     ClaudeCodeProfileListResult,
     ClaudeCodeProfileSaveResult,
-    ClaudeCodeProfileSummary
+    ClaudeCodeProfileSummary,
+    Settings,
+    UpdateSettingsRequest
 } from "./models.js";
diff --git a/desktop/frontend/bindings/github.com/strahe/profiledeck/internal/claudecode/models.ts b/desktop/frontend/bindings/github.com/strahe/profiledeck/internal/claudecode/models.ts
index 80eec66..be50d4f 100644
--- a/desktop/frontend/bindings/github.com/strahe/profiledeck/internal/claudecode/models.ts
+++ b/desktop/frontend/bindings/github.com/strahe/profiledeck/internal/claudecode/models.ts
@@ -43,3 +43,11 @@ export interface ClaudeCodeProfileSummary {
     "updated_at_unix_ms": number;
     "warnings"?: string[] | null;
 }
+
+export interface Settings {
+    "usage_sync_interval_seconds": number;
+}
+
+export interface UpdateSettingsRequest {
+    "usage_sync_interval_seconds"?: number | null;
+}
diff --git a/desktop/frontend/bindings/github.com/strahe/profiledeck/internal/usage/models.ts b/desktop/frontend/bindings/github.com/strahe/profiledeck/internal/usage/models.ts
index a21f718..80714eb 100644
--- a/desktop/frontend/bindings/github.com/strahe/profiledeck/internal/usage/models.ts
+++ b/desktop/frontend/bindings/github.com/strahe/profiledeck/internal/usage/models.ts
@@ -2,6 +2,13 @@
 // This file is automatically generated. DO NOT EDIT
 
 export interface UsageAggregateSummary {
+    "missing_output_cost_event_count": number;
+    "missing_cache_ttl_event_count": number;
+    "missing_cache_rate_event_count": number;
+    "token_total_status": string;
+    "output_tokens_status": string;
+    "incomplete_event_count": number;
+    "conflicting_event_count": number;
     "event_count": number;
     "session_count": number;
     "fresh_input_tokens": number;
@@ -28,6 +35,7 @@ export interface UsageAggregateSummary {
 }
 
 export interface UsageImportSummary {
+    "invalid_reasons": { [_ in string]?: number } | null;
     "tracked_files": number;
     "last_synced_at_unix_ms": number;
     "invalid_lines": number;
@@ -85,6 +93,10 @@ export interface UsageResolvedRange {
 }
 
 export interface UsageSummaryResult {
+    "token_total_status": string;
+    "output_tokens_status": string;
+    "incomplete_event_count": number;
+    "conflicting_event_count": number;
     "provider_id": string;
     "source": string;
     "sources": string[] | null;
@@ -94,6 +106,7 @@ export interface UsageSummaryResult {
     "output_tokens": number;
     "total_tokens": number;
     "estimated_cost_usd": string | null;
+    "known_estimated_cost_usd": string;
     "cost_status": string;
     "unknown_cost_event_count": number;
     "estimated_cost_event_count": number;
diff --git a/desktop/frontend/src/features/settings/ClaudeCodeSettings.svelte b/desktop/frontend/src/features/settings/ClaudeCodeSettings.svelte
new file mode 100644
index 0000000..db245d6
--- /dev/null
+++ b/desktop/frontend/src/features/settings/ClaudeCodeSettings.svelte
@@ -0,0 +1,124 @@
+<script lang="ts">
+	import { onMount } from "svelte";
+	import type { CancellablePromise } from "@wailsio/runtime";
+	import { _ } from "svelte-i18n";
+
+	import { ClaudeCodeService } from "../../../bindings/github.com/strahe/profiledeck/desktop/backend";
+	import type { Settings } from "../../../bindings/github.com/strahe/profiledeck/internal/claudecode/models";
+
+	import ContentContainer from "$lib/components/app/ContentContainer.svelte";
+	import { Button } from "$lib/components/ui/button";
+	import * as Empty from "$lib/components/ui/empty";
+	import { isCancelError } from "$lib/desktop-errors";
+	import { translate } from "$lib/i18n";
+
+	import UsageSyncSettings from "./UsageSyncSettings.svelte";
+	import { usageIntervals, usageSyncIntervalDefault } from "./usage-sync-settings";
+
+	let {
+		providerExists,
+		onOpenProfiles,
+		showError,
+		showNotice,
+	}: {
+		providerExists: boolean;
+		onOpenProfiles: () => void;
+		showError: (value: unknown) => void;
+		showNotice: (title: string, description: string) => void;
+	} = $props();
+
+	let settings = $state<Settings | null>(null);
+	let loading = $state(false);
+	let busy = $state(false);
+	let loadStarted = $state(false);
+	let request: CancellablePromise<Settings> | null = null;
+
+	onMount(() => {
+		return () => request?.cancel("Claude Code settings unmounted");
+	});
+
+	$effect(() => {
+		if (providerExists && !loadStarted) {
+			loadStarted = true;
+			void load();
+		} else if (!providerExists && loadStarted) {
+			request?.cancel("Claude Code provider unavailable");
+			request = null;
+			settings = null;
+			loading = false;
+			loadStarted = false;
+		}
+	});
+
+	async function load() {
+		request?.cancel("Claude Code settings request replaced");
+		loading = true;
+		const next = ClaudeCodeService.GetSettings();
+		request = next;
+		try {
+			const value = await next;
+			if (request === next) settings = value;
+		} catch (error) {
+			if (request === next && !isCancelError(error)) showError(error);
+		} finally {
+			if (request === next) {
+				request = null;
+				loading = false;
+			}
+		}
+	}
+
+	async function changeInterval(value: string) {
+		const interval = Number(value);
+		if (
+			busy
+			|| !usageIntervals.includes(interval as (typeof usageIntervals)[number])
+			|| settings?.usage_sync_interval_seconds === interval
+		) return;
+		busy = true;
+		request?.cancel("Claude Code settings update replaced");
+		const next = ClaudeCodeService.UpdateSettings({ usage_sync_interval_seconds: interval });
+		request = next;
+		try {
+			const value = await next;
+			if (request !== next) return;
+			settings = value;
+			showNotice(
+				translate("notice.settingsSaved.title"),
+				translate("notice.settingsSaved.claudeCodeDescription"),
+			);
+		} catch (error) {
+			if (request === next && !isCancelError(error)) {
+				showError(error);
+				void load();
+			}
+		} finally {
+			if (request === next) request = null;
+			busy = false;
+		}
+	}
+</script>
+
+<ContentContainer class="max-w-4xl">
+	{#if !providerExists}
+		<Empty.Root class="rounded-lg border bg-card py-12">
+			<Empty.Header>
+				<Empty.Title>{$_("usage.providerUnavailableTitle")}</Empty.Title>
+				<Empty.Description>
+					{$_("usage.providerUnavailableDescription", { values: { provider: "Claude Code" } })}
+				</Empty.Description>
+			</Empty.Header>
+			<Empty.Content>
+				<Button onclick={onOpenProfiles}>{$_("usage.openProfiles")}</Button>
+			</Empty.Content>
+		</Empty.Root>
+	{:else}
+		<UsageSyncSettings
+			id="claude-code-usage-sync"
+			interval={settings?.usage_sync_interval_seconds ?? usageSyncIntervalDefault}
+			{loading}
+			{busy}
+			onChange={changeInterval}
+		/>
+	{/if}
+</ContentContainer>
diff --git a/desktop/frontend/src/features/usage/UsageModelTable.svelte b/desktop/frontend/src/features/usage/UsageModelTable.svelte
index 8f6a902..ab8e86b 100644
--- a/desktop/frontend/src/features/usage/UsageModelTable.svelte
+++ b/desktop/frontend/src/features/usage/UsageModelTable.svelte
@@ -1,4 +1,5 @@
 <script lang="ts">
+	import { usageTokenLabel } from "./token-format";
 	import { _ } from "svelte-i18n";
 	import type { UsageModelSummary } from "../../../bindings/github.com/strahe/profiledeck/internal/usage/models";
 
@@ -65,7 +66,7 @@
 							</div>
 						</Table.Cell>
 					{/if}
-					<Table.Cell class="text-right tabular-nums">{formatInteger(model.summary.total_tokens)}</Table.Cell>
+					<Table.Cell class="text-right tabular-nums">{usageTokenLabel(formatInteger(model.summary.total_tokens), model.summary.token_total_status)}</Table.Cell>
 					<Table.Cell class="text-right tabular-nums">{formatInteger(model.summary.session_count)}</Table.Cell>
 				</Table.Row>
 			{/each}
diff --git a/desktop/frontend/src/features/usage/UsagePage.svelte b/desktop/frontend/src/features/usage/UsagePage.svelte
index 6b4d712..87538ee 100644
--- a/desktop/frontend/src/features/usage/UsagePage.svelte
+++ b/desktop/frontend/src/features/usage/UsagePage.svelte
@@ -1,4 +1,5 @@
 <script lang="ts">
+	import { usageTokenLabel } from "./token-format";
 	import { onMount } from "svelte";
 	import { Events, type CancellablePromise } from "@wailsio/runtime";
 	import { _ } from "svelte-i18n";
@@ -238,15 +239,20 @@
 		return autoSyncStatus?.last_success_at_unix_ms || report?.import.last_synced_at_unix_ms || 0;
 	}
 
-	function dataQualityIssueCount(value: UsageReportResult): number {
-		return Number(autoSyncStatus?.outcome === "warning")
-			+ Number(value.import.invalid_lines > 0 || value.import.unsupported_lines > 0)
-			+ Number(value.summary.undated_event_count > 0)
-			+ Number(value.summary.partial_cost_event_count > 0)
-			+ Number(value.summary.event_count > 0 && value.summary.unknown_cost_event_count > 0)
-			+ Number(providerID === "grok-build" && value.summary.partial_reported_cost_event_count > 0)
-			+ Number(providerID === "grok-build" && value.summary.event_count > 0 && value.summary.unknown_reported_cost_event_count > 0);
+	function unclassifiedInvalidLines(value: UsageReportResult): number {
+		return Math.max(0, value.import.invalid_lines - Object.values(value.import.invalid_reasons ?? {}).reduce<number>((sum, count) => sum + (count ?? 0), 0));
 	}
+
+	function hasDataQualityDetails(value: UsageReportResult): boolean {
+		return autoSyncStatus?.outcome === "warning"
+			|| value.import.invalid_lines > 0 || value.import.unsupported_lines > 0
+			|| value.summary.undated_event_count > 0
+			|| value.summary.missing_cache_ttl_event_count > 0 || value.summary.missing_cache_rate_event_count > 0
+			|| (providerID !== "claude-code" && value.summary.partial_cost_event_count > 0)
+			|| value.summary.unknown_cost_event_count > 0
+			|| (providerID === "grok-build" && (value.summary.partial_reported_cost_event_count > 0 || value.summary.unknown_reported_cost_event_count > 0));
+	}
+
 </script>
 
 <ContentContainer class="max-w-6xl">
@@ -300,20 +306,32 @@
 	{#if (loading && (!report || report.summary.event_count === 0)) || (report?.summary.event_count === 0 && initialSyncPending)}
 		<div class="grid min-h-56 place-items-center rounded-lg border bg-card"><Spinner class="size-5" /></div>
 	{:else if report}
-		{#if autoSyncStatus?.outcome === "warning" || report.import.invalid_lines > 0 || report.import.unsupported_lines > 0 || report.summary.undated_event_count > 0 || report.summary.partial_cost_event_count > 0 || (report.summary.event_count > 0 && report.summary.unknown_cost_event_count > 0) || (providerID === "grok-build" && (report.summary.partial_reported_cost_event_count > 0 || (report.summary.event_count > 0 && report.summary.unknown_reported_cost_event_count > 0)))}
+		{#if autoSyncStatus?.outcome === "warning" || report.import.invalid_lines > 0 || report.import.unsupported_lines > 0 || report.summary.undated_event_count > 0 || report.summary.incomplete_event_count > 0 || report.summary.conflicting_event_count > 0 || report.summary.partial_cost_event_count > 0 || (report.summary.event_count > 0 && report.summary.unknown_cost_event_count > 0) || (providerID === "grok-build" && (report.summary.partial_reported_cost_event_count > 0 || (report.summary.event_count > 0 && report.summary.unknown_reported_cost_event_count > 0)))}
 			<Alert.Root>
 				<Alert.Title>{$_("usage.dataQuality.title")}</Alert.Title>
 				<Alert.Description>
-					<p>{$_("usage.dataQuality.summary", { values: { count: dataQualityIssueCount(report) } })}</p>
+					{#if report.summary.incomplete_event_count > 0}
+						<p>{$_(providerID === "claude-code" ? "usage.claudeIncompleteUsage" : "usage.incompleteUsage", { values: { count: formatInteger(report.summary.incomplete_event_count) } })}</p>
+					{/if}
+					{#if report.summary.conflicting_event_count > 0}
+						<p>{$_("usage.conflictingUsage", { values: { count: formatInteger(report.summary.conflicting_event_count) } })}</p>
+					{/if}
+					{#if hasDataQualityDetails(report)}
 					<Accordion.Root type="single" class="mt-1">
 						<Accordion.Item value="details" class="border-0">
 							<Accordion.Trigger class="py-1 text-xs">{$_("usage.dataQuality.showDetails")}</Accordion.Trigger>
 							<Accordion.Content>
 								<ul class="flex list-disc flex-col gap-1 pl-4">
 									{#if autoSyncStatus?.outcome === "warning"}<li>{$_("usage.dataQuality.fileErrors", { values: { count: autoSyncStatus.import_error_count } })}</li>{/if}
-									{#if report.import.invalid_lines > 0 || report.import.unsupported_lines > 0}<li>{$_("usage.dataQuality.lines", { values: { invalid: formatInteger(report.import.invalid_lines), unsupported: formatInteger(report.import.unsupported_lines) } })}</li>{/if}
+									{#each Object.entries(report.import.invalid_reasons ?? {}) as [reason, count]}
+										{#if typeof count === "number" && count > 0}<li>{$_(`usage.dataQuality.invalidReasons.${reason}`, { values: { count: formatInteger(count) } })}</li>{/if}
+									{/each}
+									{#if unclassifiedInvalidLines(report) > 0}<li>{$_("usage.dataQuality.invalidLines", { values: { count: formatInteger(unclassifiedInvalidLines(report)) } })}</li>{/if}
+									{#if report.import.unsupported_lines > 0}<li>{$_("usage.dataQuality.unsupportedLines", { values: { count: formatInteger(report.import.unsupported_lines) } })}</li>{/if}
 									{#if report.summary.undated_event_count > 0}<li>{$_("usage.dataQuality.undated", { values: { count: formatInteger(report.summary.undated_event_count) } })}</li>{/if}
-									{#if report.summary.partial_cost_event_count > 0}<li>{$_("usage.dataQuality.partialPricing", { values: { count: formatInteger(report.summary.partial_cost_event_count) } })}</li>{/if}
+									{#if report.summary.missing_cache_ttl_event_count > 0}<li>{$_("usage.dataQuality.missingCacheTTL", { values: { count: formatInteger(report.summary.missing_cache_ttl_event_count) } })}</li>{/if}
+									{#if report.summary.missing_cache_rate_event_count > 0}<li>{$_("usage.dataQuality.missingCacheRate", { values: { count: formatInteger(report.summary.missing_cache_rate_event_count) } })}</li>{/if}
+									{#if providerID !== "claude-code" && report.summary.partial_cost_event_count > 0}<li>{$_("usage.dataQuality.partialPricing", { values: { count: formatInteger(report.summary.partial_cost_event_count) } })}</li>{/if}
 									{#if report.summary.event_count > 0 && report.summary.unknown_cost_event_count > 0}<li>{$_("usage.dataQuality.pricing", { values: { count: formatInteger(report.summary.unknown_cost_event_count), coverage: formatPercent(report.summary.pricing_coverage) } })}</li>{/if}
 									{#if providerID === "grok-build" && report.summary.partial_reported_cost_event_count > 0}<li>{$_("usage.dataQuality.partialReportedCost", { values: { count: formatInteger(report.summary.partial_reported_cost_event_count) } })}</li>{/if}
 									{#if providerID === "grok-build" && report.summary.event_count > 0 && report.summary.unknown_reported_cost_event_count > 0}<li>{$_("usage.dataQuality.reportedCost", { values: { count: formatInteger(report.summary.unknown_reported_cost_event_count) } })}</li>{/if}
@@ -321,6 +339,7 @@
 							</Accordion.Content>
 						</Accordion.Item>
 					</Accordion.Root>
+					{/if}
 				</Alert.Description>
 			</Alert.Root>
 		{/if}
@@ -388,7 +407,7 @@
 				<Card.Root>
 					<Card.Header class="gap-1 py-3">
 						<Card.Description>{$_("usage.totalTokens")}</Card.Description>
-						<Card.Title class="text-xl tabular-nums">{formatCompact(report.summary.total_tokens)}</Card.Title>
+						<Card.Title class="text-xl tabular-nums">{usageTokenLabel(formatCompact(report.summary.total_tokens), report.summary.token_total_status)}</Card.Title>
 					</Card.Header>
 				</Card.Root>
 			</div>
diff --git a/desktop/frontend/src/features/usage/UsageTrendChart.svelte b/desktop/frontend/src/features/usage/UsageTrendChart.svelte
index 3b416e8..b1b957a 100644
--- a/desktop/frontend/src/features/usage/UsageTrendChart.svelte
+++ b/desktop/frontend/src/features/usage/UsageTrendChart.svelte
@@ -1,4 +1,5 @@
 <script lang="ts">
+	import { usageTokenLabel } from "./token-format";
 	import { tick } from "svelte";
 	import { _ } from "svelte-i18n";
 	import type { UsageResolvedRange, UsageTrendPoint } from "../../../bindings/github.com/strahe/profiledeck/internal/usage/models";
@@ -235,8 +236,8 @@
 			bucket: fullBucketLabel(point.start_unix_ms),
 			fresh: formatInteger(point.summary.fresh_input_tokens),
 			cached: formatInteger(point.summary.cached_input_tokens),
-			output: formatInteger(point.summary.output_tokens),
-			total: formatInteger(point.summary.total_tokens),
+			output: usageTokenLabel(formatInteger(point.summary.output_tokens), point.summary.output_tokens_status),
+			total: usageTokenLabel(formatInteger(point.summary.total_tokens), point.summary.token_total_status),
 		});
 	}
 
@@ -412,11 +413,11 @@
 					<div class="mt-1 flex items-center justify-between gap-4 text-muted-foreground"><span>{$_("usage.chart.coverage")}</span><span class="font-mono tabular-nums">{formatPercent(coverage)}</span></div>
 				{/if}
 			{:else}
-				<div class="mt-1 flex items-center justify-between gap-4"><span>{$_("usage.total")}</span><span class="font-mono tabular-nums">{formatInteger(tooltipPoint.summary.total_tokens)}</span></div>
+				<div class="mt-1 flex items-center justify-between gap-4"><span>{$_("usage.total")}</span><span class="font-mono tabular-nums">{usageTokenLabel(formatInteger(tooltipPoint.summary.total_tokens), tooltipPoint.summary.token_total_status)}</span></div>
 				<div class="mt-1 grid grid-cols-2 gap-x-4 text-muted-foreground">
 					<span>{$_("usage.freshInput")}</span><span class="text-right font-mono tabular-nums">{formatInteger(tooltipPoint.summary.fresh_input_tokens)}</span>
 					<span>{$_("usage.cachedInput")}</span><span class="text-right font-mono tabular-nums">{formatInteger(tooltipPoint.summary.cached_input_tokens)}</span>
-					<span>{$_("usage.output")}</span><span class="text-right font-mono tabular-nums">{formatInteger(tooltipPoint.summary.output_tokens)}</span>
+					<span>{$_("usage.output")}</span><span class="text-right font-mono tabular-nums">{usageTokenLabel(formatInteger(tooltipPoint.summary.output_tokens), tooltipPoint.summary.output_tokens_status)}</span>
 				</div>
 			{/if}
 		</div>
diff --git a/desktop/frontend/src/features/usage/token-format.ts b/desktop/frontend/src/features/usage/token-format.ts
new file mode 100644
index 0000000..9e15c88
--- /dev/null
+++ b/desktop/frontend/src/features/usage/token-format.ts
@@ -0,0 +1,7 @@
+import { translate } from "$lib/i18n";
+
+export function usageTokenLabel(formatted: string, status: string): string {
+	if (status === "unknown") return translate("usage.tokensUnknown");
+	if (status === "partial") return translate("usage.tokensAtLeast", { value: formatted });
+	return formatted;
+}
diff --git a/desktop/frontend/src/features/workspace/Workspace.svelte b/desktop/frontend/src/features/workspace/Workspace.svelte
index c031fbd..a8e773e 100644
--- a/desktop/frontend/src/features/workspace/Workspace.svelte
+++ b/desktop/frontend/src/features/workspace/Workspace.svelte
@@ -117,6 +117,7 @@
 	const loadClaudeCodeProfiles = () => import("../profiles/ClaudeCodeProfiles.svelte");
 	const loadUsagePage = () => import("../usage/UsagePage.svelte");
 	const loadCodexSettings = () => import("../settings/CodexSettings.svelte");
+	const loadClaudeCodeSettings = () => import("../settings/ClaudeCodeSettings.svelte");
 	const loadGrokBuildSettings = () => import("../settings/GrokBuildSettings.svelte");
 	const loadGlobalSettings = () => import("./GlobalSettings.svelte");
 	const loadDiagnosticsPage = () => import("./DiagnosticsPage.svelte");
@@ -206,9 +207,9 @@
 		const enabled = new Set<string>(states.filter((state) => state.enabled).map((state) => String(state.manifest.id)));
 		return agents.filter((agent) => enabled.has(agent.id));
 	});
-	let activeAgentTab = $derived(workspaceRoute.view === "codex-settings" || workspaceRoute.view === "grok-build-settings"
+	let activeAgentTab = $derived(workspaceRoute.view === "codex-settings" || workspaceRoute.view === "grok-build-settings" || workspaceRoute.view === "claude-code-settings"
 		? "settings"
-		: workspaceRoute.view === "grok-build-usage"
+		: workspaceRoute.view === "grok-build-usage" || workspaceRoute.view === "claude-code-usage"
 			? "usage"
 		: workspaceRoute.view === "antigravity-profiles"
 			|| workspaceRoute.view === "claude-code-profiles"
@@ -225,9 +226,9 @@
 			?? grokBuildDetectResult?.provider_exists
 			?? false,
 	);
-	let usageProviderID = $derived(workspaceRoute.view === "grok-build-usage" ? grokBuildProviderID : codexProviderID);
-	let usageProviderName = $derived(workspaceRoute.view === "grok-build-usage" ? "Grok Build" : "Codex");
-	let usageProviderExists = $derived(workspaceRoute.view === "grok-build-usage" ? grokBuildProviderExists : codexProviderExists);
+	let usageProviderID = $derived(workspaceRoute.view === "claude-code-usage" ? claudeCodeProviderID : workspaceRoute.view === "grok-build-usage" ? grokBuildProviderID : codexProviderID);
+	let usageProviderName = $derived(workspaceRoute.view === "claude-code-usage" ? "Claude Code" : workspaceRoute.view === "grok-build-usage" ? "Grok Build" : "Codex");
+	let usageProviderExists = $derived(workspaceRoute.view === "claude-code-usage" ? (dashboard?.providers?.some((provider) => provider.id === claudeCodeProviderID) ?? false) : workspaceRoute.view === "grok-build-usage" ? grokBuildProviderExists : codexProviderExists);
 	let activeProfileID = $derived(
 		selectedAgent === "grok-build"
 			? grokBuildActiveProfileID
@@ -918,11 +919,11 @@
 	}
 
 	function selectAgentTab(value: string) {
-		if (selectedAgent !== "codex" && selectedAgent !== "grok-build") {
+		if (selectedAgent !== "codex" && selectedAgent !== "grok-build" && selectedAgent !== "claude-code") {
 			if (selectedAgent) void push(agentHome(selectedAgent));
 			return;
 		}
-		const basePath = selectedAgent === "grok-build" ? "/grok-build" : "/codex";
+		const basePath = `/${selectedAgent}`;
 		switch (value) {
 			case "profiles":
 				void push(`${basePath}/profiles`);
@@ -1170,7 +1171,7 @@
 					<Tabs.Root value={activeAgentTab} onValueChange={selectAgentTab}>
 						<Tabs.List variant="line" class="h-auto bg-transparent p-0">
 							<Tabs.Trigger value="profiles">{$_("tabs.profiles")}</Tabs.Trigger>
-							{#if selectedAgent === "codex" || selectedAgent === "grok-build"}
+							{#if selectedAgent === "codex" || selectedAgent === "grok-build" || selectedAgent === "claude-code"}
 								<Tabs.Trigger value="usage">{$_("tabs.usage")}</Tabs.Trigger>
 								<Tabs.Trigger value="settings">{$_("tabs.settings")}</Tabs.Trigger>
 							{/if}
@@ -1323,7 +1324,7 @@
 					{:catch}
 						<WorkspaceViewStatus state="error" />
 					{/await}
-				{:else if workspaceRoute.view === "usage" || workspaceRoute.view === "grok-build-usage"}
+				{:else if workspaceRoute.view === "usage" || workspaceRoute.view === "grok-build-usage" || workspaceRoute.view === "claude-code-usage"}
 					{#key `${usageProviderID}:${usageProviderExists}`}
 						{#await loadUsagePage()}
 							<WorkspaceViewStatus state="loading" />
@@ -1332,7 +1333,7 @@
 								providerID={usageProviderID}
 								providerName={usageProviderName}
 								providerExists={usageProviderExists}
-								onOpenProfiles={() => push(usageProviderID === grokBuildProviderID ? "/grok-build/profiles" : "/codex/profiles")}
+								onOpenProfiles={() => push(`/${usageProviderID}/profiles`)}
 								{showError}
 							/>
 						{:catch}
@@ -1360,6 +1361,19 @@
 					{:catch}
 						<WorkspaceViewStatus state="error" />
 					{/await}
+				{:else if workspaceRoute.view === "claude-code-settings"}
+					{#await loadClaudeCodeSettings()}
+						<WorkspaceViewStatus state="loading" />
+					{:then { default: ClaudeCodeSettings }}
+						<ClaudeCodeSettings
+							providerExists={(dashboard?.providers?.some((provider) => provider.id === claudeCodeProviderID) ?? false)}
+							onOpenProfiles={() => push("/claude-code/profiles")}
+							{showError}
+							{showNotice}
+						/>
+					{:catch}
+						<WorkspaceViewStatus state="error" />
+					{/await}
 				{:else if workspaceRoute.view === "settings"}
 					{#await loadGlobalSettings()}
 						<WorkspaceViewStatus state="loading" />
diff --git a/desktop/frontend/src/features/workspace/workspace-route-policy.ts b/desktop/frontend/src/features/workspace/workspace-route-policy.ts
index b30b246..ba778d1 100644
--- a/desktop/frontend/src/features/workspace/workspace-route-policy.ts
+++ b/desktop/frontend/src/features/workspace/workspace-route-policy.ts
@@ -10,6 +10,8 @@ export type WorkspaceView =
 	| "grok-build-profiles"
 	| "antigravity-profiles"
 	| "claude-code-profiles"
+	| "claude-code-usage"
+	| "claude-code-settings"
 	| "usage"
 	| "codex-settings"
 	| "grok-build-usage"
@@ -92,6 +94,8 @@ export function parseWorkspaceRoute(path: string): WorkspaceRoute {
 			: { ...build("antigravity-profiles"), valid: false };
 	}
 
+	if (path === "/claude-code/usage") return build("claude-code-usage");
+	if (path === "/claude-code/settings") return build("claude-code-settings");
 	if (path === "/claude-code/profiles") return build("claude-code-profiles");
 	if (path === "/claude-code/profiles/new") {
 		return build("claude-code-profiles", codexList, grokBuildList, antigravityList, { kind: "new", profileID: "" });
@@ -126,6 +130,8 @@ export function isAgentWorkspace(view: WorkspaceView): boolean {
 	return view === "profiles"
 		|| view === "antigravity-profiles"
 		|| view === "claude-code-profiles"
+	|| view === "claude-code-usage"
+	|| view === "claude-code-settings"
 		|| view === "grok-build-profiles"
 		|| view === "grok-build-usage"
 		|| view === "grok-build-settings"
@@ -135,7 +141,7 @@ export function isAgentWorkspace(view: WorkspaceView): boolean {
 
 export function agentForWorkspace(view: WorkspaceView): AgentID | null {
 	if (view === "antigravity-profiles") return "antigravity";
-	if (view === "claude-code-profiles") return "claude-code";
+	if (view === "claude-code-profiles" || view === "claude-code-usage" || view === "claude-code-settings") return "claude-code";
 	if (view === "grok-build-profiles" || view === "grok-build-usage" || view === "grok-build-settings") return "grok-build";
 	return view === "profiles" || view === "usage" || view === "codex-settings" ? "codex" : null;
 }
diff --git a/desktop/frontend/src/lib/i18n.ts b/desktop/frontend/src/lib/i18n.ts
index 071ab04..eb1c79a 100644
--- a/desktop/frontend/src/lib/i18n.ts
+++ b/desktop/frontend/src/lib/i18n.ts
@@ -723,6 +723,11 @@ const messages = {
 			missing: "Missing",
 		},
 		usage: {
+			tokensUnknown: "Unknown",
+			tokensAtLeast: "At least {value}",
+			incompleteUsage: "Incomplete requests: {count}. Totals include only known tokens.",
+			claudeIncompleteUsage: "Requests without a final output token count in this range: {count}. Input and cache tokens are included; output tokens and their cost are excluded.",
+			conflictingUsage: "Conflicting requests: {count}. Their tokens and costs are excluded from totals.",
 			title: "Usage",
 			loadFailedTitle: "Unable to load usage",
 			neverSynced: "Not synced",
@@ -753,13 +758,26 @@ const messages = {
 			},
 			dataQuality: {
 				title: "Data notes",
-				summary: "Some usage records could not be fully included in this report.",
 				showDetails: "Show details",
 				fileErrors: "{count} session files could not be imported.",
-				lines: "Skipped {invalid} invalid and {unsupported} unsupported log lines.",
+				invalidLines: "Across all scanned logs, {count} usage records failed validation and were skipped.",
+				unsupportedLines: "Across all scanned logs, {count} records use an unsupported format and were skipped.",
+				invalidReasons: {
+					malformed_json: "Across all scanned logs, {count} records contain malformed JSON and were skipped.",
+					record_too_large: "Across all scanned logs, {count} records exceed the size limit and were skipped.",
+					invalid_fields: "Across all scanned logs, {count} usage records contain incorrectly typed fields and were skipped.",
+					invalid_tokens: "Across all scanned logs, {count} usage records have missing or invalid token counts and were skipped.",
+					cache_tokens_mismatch: "Across all scanned logs, {count} usage records have a cache write total that differs from the sum of the 5-minute and 1-hour counts. These records were skipped; valid records for the same request still count.",
+					iteration_tokens_mismatch: "Across all scanned logs, {count} usage records have inconsistent iteration token counts and were skipped.",
+					invalid_identity: "Across all scanned logs, {count} usage records have invalid request identifiers and were skipped.",
+					invalid_timestamp: "Across all scanned logs, {count} usage records have invalid timestamps and were skipped.",
+					token_overflow: "Across all scanned logs, {count} usage records exceed the supported token count and were skipped.",
+				},
 				undated: "{count} undated records are excluded from the trend.",
-				partialPricing: "{count} records have a partial estimate; some charges may be missing.",
-				pricing: "{count} records have unknown pricing; the chart shows the known subtotal with {coverage} coverage.",
+				missingCacheTTL: "Requests without a cache write duration in this range: {count}. Their cache write cost is excluded; other known costs are included.",
+				missingCacheRate: "Requests with cache tokens but no applicable rate in this range: {count}. Those cache costs are excluded; other known costs are included.",
+				partialPricing: "Partially estimated requests: {count}. Cache write details or per-request input sizes are unavailable, or a cache write rate is missing. The cost subtotal may be incomplete.",
+				pricing: "Requests without a Standard API cost estimate in this range: {count}. Their costs are excluded from the subtotal.",
 				partialReportedCost: "{count} records contain a partial Grok-reported cost.",
 				reportedCost: "{count} records have no Grok-reported cost.",
 			},
@@ -1077,6 +1095,7 @@ const messages = {
 				title: "Settings saved",
 				description: "Desktop preferences updated.",
 				codexDescription: "Codex settings updated.",
+				claudeCodeDescription: "Claude Code settings saved.",
 				grokBuildDescription: "Grok Build settings updated.",
 			},
 		},
@@ -1887,6 +1906,11 @@ const messages = {
 			missing: "缺失",
 		},
 		usage: {
+			tokensUnknown: "未知",
+			tokensAtLeast: "至少 {value}",
+			incompleteUsage: "{count} 个请求的用量不完整，总计仅包含已知 token。",
+			claudeIncompleteUsage: "当前时间范围内，{count} 个请求的日志缺少最终输出 token 计数。已计入输入和缓存用量；输出 token 和输出费用未计入。",
+			conflictingUsage: "{count} 个请求的用量存在冲突，已从 token 和费用总计中排除。",
 			title: "用量",
 			loadFailedTitle: "无法加载用量",
 			neverSynced: "未同步",
@@ -1917,13 +1941,26 @@ const messages = {
 			},
 			dataQuality: {
 				title: "数据说明",
-				summary: "部分用量记录未能完整计入此报告。",
 				showDetails: "查看详情",
 				fileErrors: "{count} 个 session 文件无法导入。",
-				lines: "已跳过 {invalid} 条无效日志和 {unsupported} 条不支持的日志。",
+				invalidLines: "全部已扫描日志中，{count} 条用量记录未通过校验，已跳过。",
+				unsupportedLines: "全部已扫描日志中，{count} 条记录的格式尚不支持，已跳过。",
+				invalidReasons: {
+					malformed_json: "全部已扫描日志中，{count} 条记录的 JSON 不完整或格式错误，已跳过。",
+					record_too_large: "全部已扫描日志中，{count} 条记录超过大小限制，已跳过。",
+					invalid_fields: "全部已扫描日志中，{count} 条用量记录的字段类型错误，已跳过。",
+					invalid_tokens: "全部已扫描日志中，{count} 条用量记录缺少必需的 token 计数，或计数不是非负整数，已跳过。",
+					cache_tokens_mismatch: "全部已扫描日志中，{count} 条用量记录的缓存写入总量与五分钟、一小时明细之和不一致，已跳过这些记录；同一请求的有效记录仍会计入。",
+					iteration_tokens_mismatch: "全部已扫描日志中，{count} 条用量记录的分次调用计数与总计矛盾，或明细缺少有效计数，已跳过。",
+					invalid_identity: "全部已扫描日志中，{count} 条用量记录的请求标识不符合格式，已跳过。",
+					invalid_timestamp: "全部已扫描日志中，{count} 条用量记录的时间无效，已跳过。",
+					token_overflow: "全部已扫描日志中，{count} 条用量记录的 token 计数超过可处理范围，已跳过。",
+				},
 				undated: "{count} 条无时间记录未计入趋势图。",
-				partialPricing: "{count} 条记录为部分估算，可能缺少部分费用。",
-				pricing: "{count} 条记录没有价格；图表显示已知小计，覆盖率为 {coverage}。",
+				missingCacheTTL: "此时间范围内，{count} 个请求未记录缓存写入的有效期，未计入缓存写入费用；其他已确定的费用已计入。",
+				missingCacheRate: "此时间范围内，{count} 个请求的部分缓存用量没有适用费率，未计入这部分费用；其他已确定的费用已计入。",
+				partialPricing: "{count} 个请求只能部分估算费用：日志缺少缓存写入明细或单次请求的输入量，或没有适用的缓存写入费率。费用小计可能不完整。",
+				pricing: "此时间范围内，{count} 个请求无法按标准 API 价格估算，未计入费用小计。",
 				partialReportedCost: "{count} 条记录只包含 Grok 上报的部分成本。",
 				reportedCost: "{count} 条记录没有 Grok 上报成本。",
 			},
@@ -2241,6 +2278,7 @@ const messages = {
 				title: "设置已保存",
 				description: "桌面端偏好已更新。",
 				codexDescription: "Codex 设置已更新。",
+				claudeCodeDescription: "Claude Code 设置已保存。",
 				grokBuildDescription: "Grok Build 设置已更新。",
 			},
 		},
diff --git a/desktop/frontend/tests/usage-page.test.ts b/desktop/frontend/tests/usage-page.test.ts
index 0dc6574..1324f9b 100644
--- a/desktop/frontend/tests/usage-page.test.ts
+++ b/desktop/frontend/tests/usage-page.test.ts
@@ -61,6 +61,8 @@ function usageReport(): UsageReportResult {
 			time_zone: "UTC",
 		},
 		summary: {
+ missing_output_cost_event_count: 0, missing_cache_ttl_event_count: 0, missing_cache_rate_event_count: 0,
+ token_total_status:"complete", output_tokens_status:"complete", incomplete_event_count:0, conflicting_event_count:0,
 			event_count: 1,
 			session_count: 1,
 			fresh_input_tokens: 1_000_000,
@@ -90,6 +92,7 @@ function usageReport(): UsageReportResult {
 		import: {
 			tracked_files: 1,
 			last_synced_at_unix_ms: 200,
+			invalid_reasons: {},
 			invalid_lines: 0,
 			unsupported_lines: 0,
 		},
@@ -234,4 +237,53 @@ describe("UsagePage initial sync", () => {
 		expect(screen.queryByText(/complete cost for/)).not.toBeInTheDocument();
 	});
 
+	it.each(["codex", "grok-build"])("preserves the partial estimate explanation for %s", async (providerID) => {
+		const report = usageReport();
+		report.provider_id = providerID;
+		report.summary.cost_status = "partial";
+		report.summary.partial_cost_event_count = 1;
+		report.summary.estimated_cost_event_count = 0;
+		runtime.on.mockReturnValue(vi.fn());
+		backend.report.mockReturnValue(cancellable(Promise.resolve(report)));
+		backend.syncNow.mockReturnValue(cancellable(Promise.resolve(syncStatus({ provider_id: providerID, syncing: false }))));
+		render(UsagePage, {
+			providerID, providerName: providerID === "codex" ? "Codex" : "Grok Build", providerExists: true,
+			onOpenProfiles: vi.fn(), showError: vi.fn(),
+		}, { wrapper: TestProviders });
+		const details = await screen.findByRole("button", { name: "Show details" });
+		await act(() => details.click());
+		expect(await screen.findByText(/Partially estimated requests: 1\./)).toBeInTheDocument();
+		expect(screen.queryByText(/cache tokens but no applicable rate|1 requests/)).not.toBeInTheDocument();
+	});
+
+	it("marks incomplete Claude totals and explains excluded conflicts", async () => {
+		const report = usageReport();
+		report.provider_id = "claude-code";
+		report.summary = {
+			...report.summary,
+			token_total_status: "partial",
+			output_tokens_status: "unknown",
+			incomplete_event_count: 1,
+			missing_output_cost_event_count: 1,
+			partial_cost_event_count: 1,
+			conflicting_event_count: 1,
+		};
+		report.import.invalid_lines = 42;
+		report.import.invalid_reasons = { cache_tokens_mismatch: 42 };
+		runtime.on.mockReturnValue(vi.fn());
+		backend.report.mockReturnValue(cancellable(Promise.resolve(report)));
+		backend.syncNow.mockReturnValue(cancellable(Promise.resolve(syncStatus({ provider_id: "claude-code", syncing: false }))));
+		render(UsagePage, {
+			providerID: "claude-code", providerName: "Claude Code", providerExists: true,
+			onOpenProfiles: vi.fn(), showError: vi.fn(),
+		}, { wrapper: TestProviders });
+		expect(await screen.findByText(/At least/)).toBeInTheDocument();
+		expect(screen.getByText("Requests without a final output token count in this range: 1. Input and cache tokens are included; output tokens and their cost are excluded.")).toBeInTheDocument();
+		await act(() => screen.getByRole("button", { name: "Show details" }).click());
+		expect(await screen.findByText(/42 usage records have a cache write total that differs/)).toBeInTheDocument();
+		expect(screen.queryByText(/partial estimate|invalid and|0 unsupported/)).not.toBeInTheDocument();
+		expect(screen.getByText("Conflicting requests: 1. Their tokens and costs are excluded from totals.")).toBeInTheDocument();
+		expect(screen.queryByText("Grok-reported cost")).not.toBeInTheDocument();
+	});
+
 });
diff --git a/desktop/frontend/tests/workspace-route-policy.test.ts b/desktop/frontend/tests/workspace-route-policy.test.ts
index 0aedd0b..673eac5 100644
--- a/desktop/frontend/tests/workspace-route-policy.test.ts
+++ b/desktop/frontend/tests/workspace-route-policy.test.ts
@@ -13,6 +13,8 @@ describe("Workspace route policy", () => {
 		["/grok-build/profiles", "grok-build-profiles"],
 		["/antigravity/profiles", "antigravity-profiles"],
 		["/claude-code/profiles", "claude-code-profiles"],
+		["/claude-code/usage", "claude-code-usage"],
+		["/claude-code/settings", "claude-code-settings"],
 		["/codex/usage", "usage"],
 		["/codex/settings", "codex-settings"],
 		["/grok-build/usage", "grok-build-usage"],
@@ -61,6 +63,8 @@ describe("Workspace route policy", () => {
 		expect(agentForWorkspace("grok-build-settings")).toBe("grok-build");
 		expect(agentForWorkspace("antigravity-profiles")).toBe("antigravity");
 		expect(agentForWorkspace("claude-code-profiles")).toBe("claude-code");
+		expect(agentForWorkspace("claude-code-usage")).toBe("claude-code");
+		expect(agentForWorkspace("claude-code-settings")).toBe("claude-code");
 		expect(agentForWorkspace("settings")).toBeNull();
 		expect(agentForWorkspace("diagnostics")).toBeNull();
 		expect(agentHome("codex")).toBe("/codex/profiles");
diff --git a/docs/.vitepress/config.ts b/docs/.vitepress/config.ts
index 411734e..bb445c9 100644
--- a/docs/.vitepress/config.ts
+++ b/docs/.vitepress/config.ts
@@ -20,7 +20,8 @@ const enCodex = [
 ]
 
 const enClaudeCode = [
-  { text: 'Profiles', link: '/claude-code/profiles' }
+  { text: 'Profiles', link: '/claude-code/profiles' },
+  { text: 'Usage and Cost', link: '/claude-code/usage-cost' }
 ]
 
 const enAntigravity = [
@@ -55,7 +56,8 @@ const zhCodex = [
 ]
 
 const zhClaudeCode = [
-  { text: 'Profile', link: '/zh/claude-code/profiles' }
+  { text: 'Profile', link: '/zh/claude-code/profiles' },
+  { text: '用量与成本', link: '/zh/claude-code/usage-cost' }
 ]
 
 const zhAntigravity = [
diff --git a/docs/claude-code/usage-cost.md b/docs/claude-code/usage-cost.md
new file mode 100644
index 0000000..be5bc8e
--- /dev/null
+++ b/docs/claude-code/usage-cost.md
@@ -0,0 +1,28 @@
+# Claude Code Usage and Cost
+
+ProfileDeck reports usage from readable local Claude Code project and subagent sessions. Shared fork history is counted once. Activity cannot be assigned to a Profile, saved login, or account. Desktop syncs while running, with an independent interval in Claude Code Settings.
+
+## Sync and view usage
+
+```bash
+profiledeck-cli usage sync claude-code
+profiledeck-cli usage sync claude-code --claude-dir /path/to/claude-home
+profiledeck-cli usage report --provider claude-code --range 30d
+profiledeck-cli usage summary --provider claude-code --json
+```
+
+The log directory defaults to `CLAUDE_CONFIG_DIR`, then `~/.claude`. `--claude-dir` changes only where logs are read. Sync does not read credentials or change source files. Repeating it does not double-count requests. Report ranges are `today`, `7d`, `30d`, and `all`; dates use your local time zone.
+
+## Understand incomplete usage
+
+When a final record is missing, verified input and cache tokens still contribute. Totals show “at least” and missing output shows “unknown”. A later sync can complete the request. Restored history copies with input, output, and cache token totals cleared are skipped without a warning. Invalid candidates are skipped; contradictory valid final records are excluded from token and cost totals. The report shows incomplete and conflicting request counts. Data notes name the rejected usage fields, such as a cache write total that disagrees with its duration counts. Rejected-record counts cover all scanned logs; request and cost counts follow the selected date range.
+
+If a file is truncated or previously imported usage is rewritten, the accepted report is retained and sync shows a warning. Unreadable, unsupported, deleted, or unrecorded activity cannot be recovered. Claude Desktop and cloud sessions are not included. Deleting the Claude Code Provider also deletes its saved usage; explicit sync can reimport logs that remain available.
+
+## Understand estimates
+
+Estimates use [Claude Standard API prices](https://platform.claude.com/docs/en/about-claude/pricing), matched by exact model and date. Five-minute and one-hour cache writes have separate rates. Unknown cache duration, unsupported models, and unsupported pricing modes can leave cost partial or unknown. Only known components contribute to the subtotal. The report distinguishes missing final output counts, missing cache duration, and unavailable cache rates. Missing final output leaves only its output cost undetermined when input and cache rates are available.
+
+The first available estimate retains its selected rates when missing usage is completed. Price updates do not recalculate classified estimates. The bundled price list works offline; `usage pricing auto off` disables price-list updates. Reports do not connect to a billing service or upload usage.
+
+These figures are not invoices, subscription charges, or account limits. Saved usage excludes raw request IDs, prompts, completions, credentials, and log content; see [Local Data and Security](../reference/data-security.md).
diff --git a/docs/reference/cli.md b/docs/reference/cli.md
index 6fbed69..3b9a7fc 100644
--- a/docs/reference/cli.md
+++ b/docs/reference/cli.md
@@ -30,13 +30,14 @@ Codex and Grok Build additionally offer `config-set` management, `profile set-co
 ```bash
 profiledeck-cli usage sync codex
 profiledeck-cli usage sync grok-build
+profiledeck-cli usage sync claude-code --claude-dir /path/to/claude-home
 profiledeck-cli usage summary --provider grok-build
 profiledeck-cli usage report --provider grok-build --range 30d
 profiledeck-cli usage pricing check
 profiledeck-cli usage pricing auto off
 ```
 
-Use `--provider codex` or `--provider grok-build` for reports; the default is Codex. Report ranges are `today`, `7d`, `30d`, and `all`. See [Codex](../codex/usage-cost.md) or [Grok Build](../grok-build/usage-cost.md) for estimate limits.
+Use `--provider codex`, `--provider grok-build`, or `--provider claude-code` for reports; the default is Codex. Report ranges are `today`, `7d`, `30d`, and `all`. See [Codex](../codex/usage-cost.md), [Grok Build](../grok-build/usage-cost.md), or [Claude Code](../claude-code/usage-cost.md) for estimate limits.
 
 ## Backups and recovery
 
diff --git a/docs/reference/data-security.md b/docs/reference/data-security.md
index aeba6fc..f664876 100644
--- a/docs/reference/data-security.md
+++ b/docs/reference/data-security.md
@@ -20,7 +20,7 @@ The private backup recovery key is stored in your system credential store, not i
 
 ## Network access
 
-- Usage reports read local Codex and Grok Build sessions. Price-list checks download public rates from GitHub; local usage is not uploaded. Disable automatic checks with `profiledeck-cli usage pricing auto off`.
+- Usage reports read local Codex, Grok Build, and Claude Code sessions. Price-list checks download public rates from GitHub; local usage is not uploaded. Disable automatic checks with `profiledeck-cli usage pricing auto off`.
 - ChatGPT Codex limit checks contact Codex or OpenAI with the selected login. API Key limit checks send the saved key to the Profile's custom Base URL; HTTP does not encrypt it in transit.
 - Grok Build credits checks use the installed Grok Build app and may renew its current login.
 - Antigravity limit checks send the current access token to an unpublished Google Cloud Code service and may carry account risk. They do not refresh or write back the token.
diff --git a/docs/zh/claude-code/usage-cost.md b/docs/zh/claude-code/usage-cost.md
new file mode 100644
index 0000000..e377817
--- /dev/null
+++ b/docs/zh/claude-code/usage-cost.md
@@ -0,0 +1,28 @@
+# Claude Code 用量与成本
+
+ProfileDeck 从本地可读取的 Claude Code 项目会话和子代理会话统计用量，fork 共享历史只计一次。历史活动无法归属到 Profile、已保存登录或账号。Desktop 运行期间会自动同步，可在 Claude Code 设置中独立调整间隔。
+
+## 同步与查看用量
+
+```bash
+profiledeck-cli usage sync claude-code
+profiledeck-cli usage sync claude-code --claude-dir /path/to/claude-home
+profiledeck-cli usage report --provider claude-code --range 30d
+profiledeck-cli usage summary --provider claude-code --json
+```
+
+日志目录优先使用 `CLAUDE_CONFIG_DIR`，其次为 `~/.claude`。`--claude-dir` 只改变日志读取位置。同步不读取凭据、不修改源文件；重复同步不会重复累计请求。报告范围可选 `today`、`7d`、`30d`、`all`，日期使用本地时区。
+
+## 理解不完整用量
+
+缺少最终记录时，已验证的输入与缓存 token 仍会计入。总量显示“至少”，缺失输出显示“未知”；后续同步可以补齐请求。恢复历史时产生、且输入、输出和缓存 token 总量已清零的副本会直接跳过，不产生告警。无效候选会跳过；有效最终记录相互矛盾时，该请求不计入 token 与成本总量。报告会显示不完整和冲突的请求数量。数据说明会指出跳过记录的具体原因，例如缓存写入总量与有效期明细之和不一致。跳过记录的数量覆盖全部已扫描日志；请求和费用的数量按选定时间范围统计。
+
+日志被截断或已导入的历史用量被改写时，已接受的报告会保留，同步会显示提示。无法读取、不支持、已删除或未记录的活动无法恢复。统计不包含 Claude Desktop 或云端会话。删除 Claude Code Provider 也会删除其已保存用量；手动同步可重新导入仍存在的日志。
+
+## 理解成本估算
+
+估算依据 [Claude Standard API 价格](https://platform.claude.com/docs/en/about-claude/pricing)，按精确模型和日期匹配。五分钟与一小时缓存写入使用不同费率。缓存时长不明、模型或计价模式不支持时，成本可能部分已知或未知；小计只包含可确定的费用。报告会区分缺少最终输出计数、缺少缓存有效期和缺少缓存费率。输入与缓存的费率已知时，缺少最终输出计数只影响输出费用。
+
+首次获得估算后，补齐缺失用量继续使用当时选定的费率。价格更新不会重新计算已有分类估算。内置价格目录可离线使用，`usage pricing auto off` 可关闭价格目录更新。查看报告不会连接账单服务或上传用量。
+
+这些数字不是账单、订阅费用或账号额度。保存的用量不包含原始请求 ID、提示词、回答、凭据或日志内容，见[本地数据与安全](../reference/data-security.md)。
diff --git a/docs/zh/reference/cli.md b/docs/zh/reference/cli.md
index 8dc2108..35d7757 100644
--- a/docs/zh/reference/cli.md
+++ b/docs/zh/reference/cli.md
@@ -30,13 +30,14 @@ Codex 和 Grok Build 还提供 `config-set` 管理、`profile set-config` 和 `p
 ```bash
 profiledeck-cli usage sync codex
 profiledeck-cli usage sync grok-build
+profiledeck-cli usage sync claude-code --claude-dir /path/to/claude-home
 profiledeck-cli usage summary --provider grok-build
 profiledeck-cli usage report --provider grok-build --range 30d
 profiledeck-cli usage pricing check
 profiledeck-cli usage pricing auto off
 ```
 
-报告可使用 `--provider codex` 或 `--provider grok-build`，默认是 Codex。范围可选 `today`、`7d`、`30d`、`all`。估算限制见 [Codex](../codex/usage-cost.md) 或 [Grok Build](../grok-build/usage-cost.md)。
+报告可使用 `--provider codex`、`--provider grok-build` 或 `--provider claude-code`，默认是 Codex。范围可选 `today`、`7d`、`30d`、`all`。估算限制见 [Codex](../codex/usage-cost.md)、[Grok Build](../grok-build/usage-cost.md) 或 [Claude Code](../claude-code/usage-cost.md)。
 
 ## 备份与恢复
 
diff --git a/docs/zh/reference/data-security.md b/docs/zh/reference/data-security.md
index 66226af..301d159 100644
--- a/docs/zh/reference/data-security.md
+++ b/docs/zh/reference/data-security.md
@@ -20,7 +20,7 @@ ProfileDeck 在你的设备上保存 Profile、登录、设置、用量报告和
 
 ## 何时联网
 
-- 用量报告读取本地 Codex 和 Grok Build 会话。价格检查从 GitHub 下载公开费率，不上传本地用量。运行 `profiledeck-cli usage pricing auto off` 可关闭自动检查。
+- 用量报告读取本地 Codex、Grok Build 和 Claude Code 会话。价格检查从 GitHub 下载公开费率，不上传本地用量。运行 `profiledeck-cli usage pricing auto off` 可关闭自动检查。
 - ChatGPT Codex 限额检查使用所选登录连接 Codex 或 OpenAI。API Key 限额检查将已保存密钥发送到该 Profile 的自定义 Base URL；HTTP 不会加密传输中的密钥。
 - Grok Build credits 检查使用已安装的 Grok Build，可能续期当前登录。
 - Antigravity 限额检查将当前访问令牌发送到未公开的 Google Cloud Code 服务，可能带来账号风险；检查不会刷新或回写令牌。
diff --git a/internal/app/application.go b/internal/app/application.go
index 3ff2434..13c646a 100644
--- a/internal/app/application.go
+++ b/internal/app/application.go
@@ -13,6 +13,7 @@ import (
 	"github.com/strahe/profiledeck/internal/bootstrap"
 	"github.com/strahe/profiledeck/internal/claudecode"
 	claudeadapter "github.com/strahe/profiledeck/internal/claudecode/adapter"
+	claudeconfig "github.com/strahe/profiledeck/internal/claudecode/config"
 	claudeprofile "github.com/strahe/profiledeck/internal/claudecode/profile"
 	claudetarget "github.com/strahe/profiledeck/internal/claudecode/target"
 	"github.com/strahe/profiledeck/internal/codex"
@@ -40,6 +41,7 @@ import (
 )
 
 type Config struct {
+	ClaudeDir   string
 	ConfigDir   string
 	CodexDir    string
 	GrokHome    string
@@ -105,9 +107,15 @@ func NewWithDependencies(config Config, dependencies Dependencies) (*Application
 	if accessMode != agent.AccessUnrestricted && accessMode != agent.AccessDesktopPreferences {
 		return nil, fmt.Errorf("unsupported Agent access mode %q", accessMode)
 	}
+	claudeDir, err := claudeconfig.ResolveConfigDir(config.ClaudeDir)
+	if err != nil {
+		return nil, err
+	}
+	config.ClaudeDir = claudeDir
 	usageRegistry, err := usage.NewRegistry(
 		usage.NewCodexIntegration(config.CodexDir),
 		usage.NewGrokBuildIntegration(config.GrokHome),
+		usage.NewClaudeCodeIntegrationWithProvisioner(config.ClaudeDir, claudecode.NewUsageProvisioner()),
 	)
 	if err != nil {
 		return nil, err
diff --git a/internal/bootstrap/service_test.go b/internal/bootstrap/service_test.go
index d7e0111..1c4ef3b 100644
--- a/internal/bootstrap/service_test.go
+++ b/internal/bootstrap/service_test.go
@@ -304,7 +304,7 @@ func TestInitializeBacksUpPreviousBaselineBeforePricingCatalogMigration(t *testi
 				t.Fatalf("backup request = %#v", req)
 			}
 			snapshot := inspectDatabaseSnapshot(t, runtimeService.Paths().Database)
-			if len(snapshot.markers) != len(storemigrations.Migrations.Sorted())-1 ||
+			if len(snapshot.markers) != len(storemigrations.Migrations.Sorted())-2 ||
 				!snapshot.usageTable || !snapshot.grokUsageTable ||
 				!snapshot.usageObservationTable || !snapshot.reportedCostColumns || snapshot.pricingColumns ||
 				!snapshot.pathKeyIndex ||
@@ -318,7 +318,7 @@ func TestInitializeBacksUpPreviousBaselineBeforePricingCatalogMigration(t *testi
 	if err != nil {
 		t.Fatalf("apply pricing catalog migration: %v", err)
 	}
-	if result.MigrationsApplied != 1 || backups.calls != 1 {
+	if result.MigrationsApplied != 2 || backups.calls != 1 {
 		t.Fatalf("upgrade result = %#v, backups = %d", result, backups.calls)
 	}
 	snapshot := inspectDatabaseSnapshot(t, runtimeService.Paths().Database)
@@ -434,18 +434,30 @@ func createPreviousBaseline(t *testing.T, ctx context.Context, runtimeService *r
 		t.Fatalf("registered migrations = %d, want at least 2", len(registered))
 	}
 	execDatabaseStatements(t, runtimeService.Paths().Database,
+		`DROP TABLE claude_code_usage_import_files`,
+		`ALTER TABLE usage_facts DROP COLUMN token_status`,
+		`ALTER TABLE usage_facts DROP COLUMN cache_write_5m_tokens`,
+		`ALTER TABLE usage_facts DROP COLUMN cache_write_1h_tokens`,
+		`ALTER TABLE usage_facts DROP COLUMN pricing_eligible`,
+		`ALTER TABLE usage_facts DROP COLUMN price_snapshot_json`,
 		`ALTER TABLE usage_facts DROP COLUMN cache_creation_input_tokens`,
 		`ALTER TABLE usage_facts DROP COLUMN cache_write_input_tokens`,
 		`ALTER TABLE usage_facts DROP COLUMN pricing_catalog_version`,
 	)
 	execDatabaseStatements(t, runtimeService.Paths().Database,
-		`DELETE FROM bun_migrations WHERE name = '`+registered[len(registered)-1].Name+`'`,
+		`DELETE FROM bun_migrations WHERE name IN ('`+registered[len(registered)-1].Name+`','`+registered[len(registered)-2].Name+`')`,
 	)
 }
 
 func dropIncrementalUsageSchema(t *testing.T, path string) {
 	t.Helper()
 	execDatabaseStatements(t, path,
+		`DROP TABLE claude_code_usage_import_files`,
+		`ALTER TABLE usage_facts DROP COLUMN token_status`,
+		`ALTER TABLE usage_facts DROP COLUMN cache_write_5m_tokens`,
+		`ALTER TABLE usage_facts DROP COLUMN cache_write_1h_tokens`,
+		`ALTER TABLE usage_facts DROP COLUMN pricing_eligible`,
+		`ALTER TABLE usage_facts DROP COLUMN price_snapshot_json`,
 		`ALTER TABLE usage_facts DROP COLUMN cache_creation_input_tokens`,
 		`ALTER TABLE usage_facts DROP COLUMN cache_write_input_tokens`,
 		`ALTER TABLE usage_facts DROP COLUMN pricing_catalog_version`,
diff --git a/internal/claudecode/config/logs.go b/internal/claudecode/config/logs.go
new file mode 100644
index 0000000..bd71b61
--- /dev/null
+++ b/internal/claudecode/config/logs.go
@@ -0,0 +1,23 @@
+package config
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+func ResolveConfigDir(explicit string) (string, error) {
+	root := strings.TrimSpace(explicit)
+	if root == "" {
+		root = strings.TrimSpace(os.Getenv("CLAUDE_CONFIG_DIR"))
+	}
+	if root == "" {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return "", err
+		}
+		root = filepath.Join(home, ".claude")
+	}
+	absolute, err := filepath.Abs(root)
+	return filepath.Clean(absolute), err
+}
diff --git a/internal/claudecode/service_settings.go b/internal/claudecode/service_settings.go
new file mode 100644
index 0000000..1647f90
--- /dev/null
+++ b/internal/claudecode/service_settings.go
@@ -0,0 +1,90 @@
+package claudecode
+
+import (
+	"context"
+	"errors"
+
+	claudeconfig "github.com/strahe/profiledeck/internal/claudecode/config"
+	"github.com/strahe/profiledeck/internal/store"
+	"github.com/strahe/profiledeck/internal/usage"
+)
+
+type UpdateSettingsRequest struct {
+	UsageSyncIntervalSeconds *int `json:"usage_sync_interval_seconds,omitempty"`
+}
+
+type Settings struct {
+	UsageSyncIntervalSeconds int `json:"usage_sync_interval_seconds"`
+}
+
+func (service *Service) GetSettings(ctx context.Context) (Settings, error) {
+	if err := service.requireAccess(ctx); err != nil {
+		return Settings{}, err
+	}
+	db, err := service.stores.OpenHealthy(ctx, true)
+	if err != nil {
+		return Settings{}, err
+	}
+	defer db.Close()
+	if _, err := db.GetProvider(ctx, claudeconfig.ProviderID); err != nil &&
+		!errors.Is(err, store.ErrNotFound) {
+		return Settings{}, err
+	}
+	return getSettings(ctx, db)
+}
+
+func (service *Service) UpdateSettings(
+	ctx context.Context,
+	req UpdateSettingsRequest,
+) (Settings, error) {
+	if err := service.requireAccess(ctx); err != nil {
+		return Settings{}, err
+	}
+	db, err := service.stores.OpenHealthy(ctx, false)
+	if err != nil {
+		return Settings{}, err
+	}
+	defer db.Close()
+	var result Settings
+	err = db.WithTransaction(ctx, func(txStore *store.Store) error {
+		if _, err := requireClaudeCodeProvider(ctx, txStore); err != nil {
+			return err
+		}
+		if req.UsageSyncIntervalSeconds != nil {
+			interval, appErr := usage.NormalizeUsageSyncInterval(
+				*req.UsageSyncIntervalSeconds,
+			)
+			if appErr != nil {
+				return appErr
+			}
+			if err := usage.SaveProviderSyncSettings(
+				ctx,
+				txStore,
+				claudeconfig.ProviderID,
+				"Claude Code",
+				usage.ProviderSyncSettings{UsageSyncIntervalSeconds: interval},
+			); err != nil {
+				return err
+			}
+		}
+		var err error
+		result, err = getSettings(ctx, txStore)
+		return err
+	})
+	return result, err
+}
+
+func getSettings(ctx context.Context, db *store.Store) (Settings, error) {
+	value, err := usage.LoadProviderSyncSettings(
+		ctx,
+		db,
+		claudeconfig.ProviderID,
+		"Claude Code",
+	)
+	if err != nil {
+		return Settings{}, err
+	}
+	return Settings{
+		UsageSyncIntervalSeconds: value.UsageSyncIntervalSeconds,
+	}, nil
+}
diff --git a/internal/claudecode/usage.go b/internal/claudecode/usage.go
new file mode 100644
index 0000000..34a05d7
--- /dev/null
+++ b/internal/claudecode/usage.go
@@ -0,0 +1,37 @@
+package claudecode
+
+import (
+	"context"
+	"errors"
+
+	claudecodeconfig "github.com/strahe/profiledeck/internal/claudecode/config"
+	"github.com/strahe/profiledeck/internal/store"
+	"github.com/strahe/profiledeck/internal/usage"
+)
+
+type usageProvisioner struct{}
+
+func NewUsageProvisioner() usage.ProviderProvisioner { return usageProvisioner{} }
+
+func (usageProvisioner) Ensure(ctx context.Context, db *store.Store, mode usage.SyncProvisionMode) error {
+	provider, err := db.GetProvider(ctx, claudecodeconfig.ProviderID)
+	if err == nil {
+		_, err = validateClaudeCodeProvider(provider)
+		return err
+	}
+	if !errors.Is(err, store.ErrNotFound) {
+		return err
+	}
+	if mode != usage.SyncProvisionProvider {
+		return store.ErrUsageProviderMissing
+	}
+	locator, err := claudecodeconfig.ResolveLocator()
+	if err != nil {
+		return err
+	}
+	metadata := newClaudeCodeProviderMetadata(locator)
+	if err := ensureClaudeCodePathOwnership(ctx, db, metadata); err != nil {
+		return err
+	}
+	return createClaudeCodeProvider(ctx, db, metadata)
+}
diff --git a/internal/cli/command.go b/internal/cli/command.go
index d1aa593..74316ca 100644
--- a/internal/cli/command.go
+++ b/internal/cli/command.go
@@ -213,7 +213,7 @@ func applicationFor(cmd *urfavecli.Command) (*app.Application, error) {
 		grokHome = cmd.String(grokHomeFlagName)
 	}
 	application, err := app.New(app.Config{
-		ConfigDir: configDirValue(cmd), CodexDir: codexDir, GrokHome: grokHome,
+		ConfigDir: configDirValue(cmd), CodexDir: codexDir, GrokHome: grokHome, ClaudeDir: cmd.String(claudeDirFlagName),
 		AgentAccess: agent.AccessUnrestricted,
 	})
 	if err != nil {
diff --git a/internal/cli/command_test.go b/internal/cli/command_test.go
index b479b45..8dfff5b 100644
--- a/internal/cli/command_test.go
+++ b/internal/cli/command_test.go
@@ -27,6 +27,7 @@ import (
 	codexconfig "github.com/strahe/profiledeck/internal/codex/config"
 	"github.com/strahe/profiledeck/internal/doctor"
 	grokconfig "github.com/strahe/profiledeck/internal/grokbuild/config"
+	"github.com/strahe/profiledeck/internal/pricing"
 	"github.com/strahe/profiledeck/internal/profile"
 	"github.com/strahe/profiledeck/internal/profiletarget"
 	"github.com/strahe/profiledeck/internal/provider"
@@ -734,7 +735,7 @@ func TestUsagePricingStatusAndAutomaticSetting(t *testing.T) {
 		decodeCLIJSON(t, []byte(output), &status)
 		return status
 	}
-	if status := read(); status["automatic"] != true || status["catalog_version"] != float64(1) {
+	if status := read(); status["automatic"] != true || status["catalog_version"] != float64(pricing.Embedded().CatalogVersion) {
 		t.Fatalf("initial price status = %#v", status)
 	}
 	if _, err := runCLI(t, "--config-dir", configDir, "usage", "pricing", "auto", "off"); err != nil {
@@ -2419,3 +2420,72 @@ func assertNoTargetToolConfigCreated(t *testing.T, configDir string) {
 		}
 	}
 }
+
+func TestClaudeCodeUsageCustomDirectoryDoesNotChangeBindingsOrLeakIdentifiers(t *testing.T) {
+	configDir := t.TempDir()
+	logDir := t.TempDir()
+	envDir := t.TempDir()
+	t.Setenv("CLAUDE_CONFIG_DIR", envDir)
+	project := filepath.Join(logDir, "projects", "project")
+	if err := os.MkdirAll(project, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	line := `{"type":"assistant","requestId":"private-request-id","sessionId":"private-session-id","timestamp":"2026-09-24T12:00:00Z","message":{"id":"private-message-id","model":"claude-opus-5-5","content":[{"text":"discarded private answer"}],"stop_reason":null,"usage":{"input_tokens":70,"cache_read_input_tokens":20,"cache_creation_input_tokens":10,"output_tokens":1,"cache_creation":{"ephemeral_5m_input_tokens":0,"ephemeral_1h_input_tokens":10}}}}` + "\n"
+	if err := os.WriteFile(filepath.Join(project, "session.jsonl"), []byte(line), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	base := []string{"--config-dir", configDir}
+	if _, err := runCLI(t, append(base, "init")...); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := runCLI(t, append(base, "usage", "pricing", "auto", "off")...); err != nil {
+		t.Fatal(err)
+	}
+	syncOut, err := runCLI(t, append(base, "usage", "sync", "claude-code", "--claude-dir", logDir, "--json")...)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var synced usage.UsageSyncResult
+	decodeCLIJSON(t, []byte(syncOut), &synced)
+	if synced.ImportedEvents != 1 || synced.ScannedFiles != 1 {
+		t.Fatalf("custom logs ignored: %+v", synced)
+	}
+	human, err := runCLI(t, append(base, "usage", "summary", "--provider", "claude-code")...)
+	if err != nil || !strings.Contains(human, "total tokens: at least 100") || !strings.Contains(human, "output tokens: unknown") || !strings.Contains(human, "incomplete events: 1") {
+		t.Fatalf("partial summary: %s, %v", human, err)
+	}
+	report, err := runCLI(t, append(base, "usage", "report", "--provider", "claude-code", "--range", "all")...)
+	if err != nil || !strings.Contains(report, "requests without a final output token count in this range: 1; their output cost is excluded") {
+		t.Fatalf("partial report explanation: %s, %v", report, err)
+	}
+	for _, out := range []string{syncOut, human, report} {
+		for _, private := range []string{logDir, "private-request-id", "private-session-id", "private-message-id", "discarded private answer"} {
+			if strings.Contains(out, private) {
+				t.Fatalf("usage output disclosed %q", private)
+			}
+		}
+	}
+	db, err := store.Open(context.Background(), filepath.Join(configDir, "profiledeck", "profiledeck.db"), false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	provider, err := db.GetProvider(context.Background(), "claude-code")
+	if err != nil || strings.Contains(provider.MetadataJSON, logDir) {
+		t.Fatalf("log override changed auth binding: %+v, %v", provider, err)
+	}
+}
+
+func TestUsageReportNotesPreserveLegacyPartialEstimateExplanation(t *testing.T) {
+	for _, providerID := range []string{"codex", "grok-build"} {
+		t.Run(providerID, func(t *testing.T) {
+			var output bytes.Buffer
+			if err := writeUsageReportNotes(&output, usage.UsageReportResult{ProviderID: providerID, Summary: usage.UsageAggregateSummary{PartialCostEventCount: 1}}); err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(output.String(), "partially estimated requests: 1;") || strings.Contains(output.String(), "cache tokens but no applicable rate") {
+				t.Fatalf("partial estimate misexplained: %s", output.String())
+			}
+		})
+	}
+}
diff --git a/internal/cli/usage.go b/internal/cli/usage.go
index 0485999..65deaa7 100644
--- a/internal/cli/usage.go
+++ b/internal/cli/usage.go
@@ -16,6 +16,7 @@ import (
 
 const (
 	codexDirFlagName   = "codex-dir"
+	claudeDirFlagName  = "claude-dir"
 	usageRangeFlagName = "range"
 )
 
@@ -69,6 +70,7 @@ func newUsageSyncCommand() *urfavecli.Command {
 		Commands: []*urfavecli.Command{
 			newUsageSyncCodexCommand(),
 			newUsageSyncGrokBuildCommand(),
+			newUsageSyncClaudeCodeCommand(),
 		},
 	}
 }
@@ -126,6 +128,33 @@ func newUsageSyncGrokBuildCommand() *urfavecli.Command {
 	}
 }
 
+func newUsageSyncClaudeCodeCommand() *urfavecli.Command {
+	return &urfavecli.Command{
+		Name:  "claude-code",
+		Usage: "Import Claude Code local session usage",
+		Flags: []urfavecli.Flag{
+			stringFlag(claudeDirFlagName, "Claude Code log directory"),
+			boolFlag(jsonFlagName, "Write JSON output"),
+		},
+		Action: func(ctx context.Context, cmd *urfavecli.Command) error {
+			application, err := applicationFor(cmd)
+			if err != nil {
+				return err
+			}
+			_, _ = application.Pricing().Check(ctx, false)
+			result, err := application.Usage().Sync(ctx, usage.UsageSyncRequest{ProviderID: "claude-code"})
+			if err != nil {
+				return err
+			}
+			w := outputWriter(cmd)
+			if cmd.Bool(jsonFlagName) {
+				return writeJSON(w, result)
+			}
+			return writeUsageSyncResult(w, result)
+		},
+	}
+}
+
 func newUsageSummaryCommand() *urfavecli.Command {
 	return &urfavecli.Command{
 		Name:  "summary",
@@ -157,12 +186,13 @@ func newUsageSummaryCommand() *urfavecli.Command {
 func writeUsageSyncResult(w io.Writer, result usage.UsageSyncResult) error {
 	if _, err := fmt.Fprintf(
 		w,
-		"Usage sync\nprovider: %s\nsource: %s\nscanned files: %d\nskipped unchanged files: %d\nimported events: %d\nskipped duplicate events: %d\nunsupported lines: %d\ninvalid lines: %d\nerrors: %d\n",
+		"Usage sync\nprovider: %s\nsource: %s\nscanned files: %d\nskipped unchanged files: %d\nimported events: %d\nupdated events: %d\nskipped duplicate events: %d\nunsupported lines: %d\ninvalid lines: %d\nerrors: %d\n",
 		result.ProviderID,
 		result.Source,
 		result.ScannedFiles,
 		result.SkippedUnchangedFiles,
 		result.ImportedEvents,
+		result.UpdatedEvents,
 		result.SkippedDuplicateEvents,
 		result.UnsupportedLines,
 		result.InvalidLines,
@@ -213,17 +243,20 @@ func writeUsageSummary(w io.Writer, result usage.UsageSummaryResult) error {
 	sources := strings.Join(result.Sources, ",")
 	if _, err := fmt.Fprintf(
 		w,
-		"Usage summary\nprovider: %s\nsource: %s\nsources: %s\nevents: %d\ninput tokens: %d\ncached input tokens: %d\noutput tokens: %d\ntotal tokens: %d\nAPI-equivalent cost status: %s\nAPI-equivalent estimated cost usd: %s\nunknown API-equivalent cost events: %d\n",
+		"Usage summary\nprovider: %s\nsource: %s\nsources: %s\nevents: %d\ninput tokens: %d\ncached input tokens: %d\noutput tokens: %s\ntotal tokens: %s\nincomplete events: %d\nconflicting events: %d\nAPI-equivalent cost status: %s\nAPI-equivalent estimated cost usd: %s\nknown API-equivalent estimated cost usd: %s\nunknown API-equivalent cost events: %d\n",
 		result.ProviderID,
 		result.Source,
 		sources,
 		result.EventCount,
 		result.InputTokens,
 		result.CachedInputTokens,
-		result.OutputTokens,
-		result.TotalTokens,
+		usageTokenValue(result.OutputTokens, result.OutputTokensStatus),
+		usageTokenValue(result.TotalTokens, result.TokenTotalStatus),
+		result.IncompleteEventCount,
+		result.ConflictingEventCount,
 		result.CostStatus,
 		cost,
+		result.KnownEstimatedCostUSD,
 		result.UnknownCostEventCount,
 	); err != nil {
 		return err
@@ -261,7 +294,7 @@ func writeUsageReport(w io.Writer, result usage.UsageReportResult) error {
 	}
 	if _, err := fmt.Fprintf(
 		w,
-		"Usage report\nprovider: %s\nrange: %s\ntime zone: %s\nevents: %d\nsessions: %d\nfresh input tokens: %d\ncached input tokens: %d\noutput tokens: %d\ntotal tokens: %d\ncache hit rate: %.1f%%\nknown API-equivalent estimated cost usd: %s\nAPI-equivalent cost status: %s\npricing coverage: %.1f%%\n%sundated events: %d\ntracked files: %d\nlast sync: %s\ninvalid lines: %d\nunsupported lines: %d\npricing basis: %s\n\nTrend\n",
+		"Usage report\nprovider: %s\nrange: %s\ntime zone: %s\nevents: %d\nsessions: %d\nfresh input tokens: %d\ncached input tokens: %d\noutput tokens: %s\ntotal tokens: %s\nincomplete events: %d\nconflicting events: %d\ncache hit rate: %.1f%%\nknown API-equivalent estimated cost usd: %s\nAPI-equivalent cost status: %s\npricing coverage: %.1f%%\n%sundated events: %d\ntracked files: %d\nlast sync: %s\ninvalid lines: %d\nunsupported lines: %d\npricing basis: %s\n",
 		result.ProviderID,
 		result.Range.Preset,
 		result.Range.TimeZone,
@@ -269,8 +302,10 @@ func writeUsageReport(w io.Writer, result usage.UsageReportResult) error {
 		result.Summary.SessionCount,
 		result.Summary.FreshInputTokens,
 		result.Summary.CachedInputTokens,
-		result.Summary.OutputTokens,
-		result.Summary.TotalTokens,
+		usageTokenValue(result.Summary.OutputTokens, result.Summary.OutputTokensStatus),
+		usageTokenValue(result.Summary.TotalTokens, result.Summary.TokenTotalStatus),
+		result.Summary.IncompleteEventCount,
+		result.Summary.ConflictingEventCount,
 		result.Summary.CacheHitRate*100,
 		result.Summary.KnownEstimatedCostUSD,
 		result.Summary.CostStatus,
@@ -286,6 +321,12 @@ func writeUsageReport(w io.Writer, result usage.UsageReportResult) error {
 		return err
 	}
 
+	if err := writeUsageReportNotes(w, result); err != nil {
+		return err
+	}
+	if _, err := fmt.Fprintln(w, "\nTrend"); err != nil {
+		return err
+	}
 	table := tabwriter.NewWriter(w, 0, 4, 2, ' ', 0)
 	showReportedCost := result.ProviderID == grokconfig.ProviderID
 	if showReportedCost {
@@ -297,15 +338,15 @@ func writeUsageReport(w io.Writer, result usage.UsageReportResult) error {
 	}
 	for _, point := range result.Trend {
 		if showReportedCost {
-			if _, err := fmt.Fprintf(table, "%s\t%d\t%d\t%d\t%d\t%s\t%s\n",
+			if _, err := fmt.Fprintf(table, "%s\t%d\t%d\t%s\t%s\t%s\t%s\n",
 				usageBucketLabel(result.Range, point.StartUnixMS), point.Summary.FreshInputTokens,
-				point.Summary.CachedInputTokens, point.Summary.OutputTokens, point.Summary.TotalTokens,
+				point.Summary.CachedInputTokens, usageTokenValue(point.Summary.OutputTokens, point.Summary.OutputTokensStatus), usageTokenValue(point.Summary.TotalTokens, point.Summary.TokenTotalStatus),
 				point.Summary.KnownEstimatedCostUSD, point.Summary.KnownReportedCostUSD); err != nil {
 				return err
 			}
-		} else if _, err := fmt.Fprintf(table, "%s\t%d\t%d\t%d\t%d\t%s\n",
+		} else if _, err := fmt.Fprintf(table, "%s\t%d\t%d\t%s\t%s\t%s\n",
 			usageBucketLabel(result.Range, point.StartUnixMS), point.Summary.FreshInputTokens,
-			point.Summary.CachedInputTokens, point.Summary.OutputTokens, point.Summary.TotalTokens,
+			point.Summary.CachedInputTokens, usageTokenValue(point.Summary.OutputTokens, point.Summary.OutputTokensStatus), usageTokenValue(point.Summary.TotalTokens, point.Summary.TokenTotalStatus),
 			point.Summary.KnownEstimatedCostUSD); err != nil {
 			return err
 		}
@@ -326,15 +367,15 @@ func writeUsageReport(w io.Writer, result usage.UsageReportResult) error {
 	}
 	for _, model := range result.Models {
 		if showReportedCost {
-			if _, err := fmt.Fprintf(table, "%s\t%d\t%d\t%.1f%%\t%s\t%s\t%s\t%s\n",
-				model.Model, model.Summary.SessionCount, model.Summary.TotalTokens,
+			if _, err := fmt.Fprintf(table, "%s\t%d\t%s\t%.1f%%\t%s\t%s\t%s\t%s\n",
+				model.Model, model.Summary.SessionCount, usageTokenValue(model.Summary.TotalTokens, model.Summary.TokenTotalStatus),
 				model.Summary.CacheHitRate*100, model.Summary.KnownEstimatedCostUSD,
 				model.Summary.CostStatus, model.Summary.KnownReportedCostUSD,
 				model.Summary.ReportedCostStatus); err != nil {
 				return err
 			}
-		} else if _, err := fmt.Fprintf(table, "%s\t%d\t%d\t%.1f%%\t%s\t%s\n",
-			model.Model, model.Summary.SessionCount, model.Summary.TotalTokens,
+		} else if _, err := fmt.Fprintf(table, "%s\t%d\t%s\t%.1f%%\t%s\t%s\n",
+			model.Model, model.Summary.SessionCount, usageTokenValue(model.Summary.TotalTokens, model.Summary.TokenTotalStatus),
 			model.Summary.CacheHitRate*100, model.Summary.KnownEstimatedCostUSD,
 			model.Summary.CostStatus); err != nil {
 			return err
@@ -343,6 +384,49 @@ func writeUsageReport(w io.Writer, result usage.UsageReportResult) error {
 	return table.Flush()
 }
 
+func writeUsageReportNotes(w io.Writer, result usage.UsageReportResult) error {
+	if result.ProviderID != "claude-code" && result.Summary.PartialCostEventCount > 0 {
+		if _, err := fmt.Fprintf(w, "partially estimated requests: %d; cache write details or per-request input sizes are unavailable, or a cache write rate is missing; the cost subtotal may be incomplete\n", result.Summary.PartialCostEventCount); err != nil {
+			return err
+		}
+	}
+	for _, note := range []struct {
+		count int64
+		text  string
+	}{
+		{result.Summary.MissingOutputCostEventCount, "requests without a final output token count in this range: %d; their output cost is excluded\n"},
+		{result.Summary.MissingCacheTTLEventCount, "requests without a cache write duration in this range: %d; their cache write cost is excluded\n"},
+		{result.Summary.MissingCacheRateEventCount, "requests with cache tokens but no applicable rate in this range: %d; those cache costs are excluded\n"},
+	} {
+		if note.count > 0 {
+			if _, err := fmt.Fprintf(w, note.text, note.count); err != nil {
+				return err
+			}
+		}
+	}
+	for _, reason := range []struct {
+		key  string
+		text string
+	}{
+		{"malformed_json", "malformed JSON"},
+		{"record_too_large", "record size exceeds the limit"},
+		{"invalid_fields", "incorrectly typed fields"},
+		{"invalid_tokens", "missing or invalid token counts"},
+		{"cache_tokens_mismatch", "cache write total differs from the 5-minute and 1-hour counts"},
+		{"iteration_tokens_mismatch", "inconsistent iteration token counts"},
+		{"invalid_identity", "invalid request identifiers"},
+		{"invalid_timestamp", "invalid timestamps"},
+		{"token_overflow", "token count exceeds the supported range"},
+	} {
+		if count := result.Import.InvalidReasons[reason.key]; count > 0 {
+			if _, err := fmt.Fprintf(w, "skipped across all scanned logs: %d records (%s)\n", count, reason.text); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
 func usageBucketLabel(resolved usage.UsageResolvedRange, unixMS int64) string {
 	location := time.Local
 	if resolved.TimeZone != "" {
@@ -362,3 +446,14 @@ func usageBucketLabel(resolved usage.UsageResolvedRange, unixMS int64) string {
 		return value.Format("2006-01-02")
 	}
 }
+
+func usageTokenValue(value int64, status string) string {
+	switch status {
+	case "unknown":
+		return "unknown"
+	case "partial":
+		return fmt.Sprintf("at least %d", value)
+	default:
+		return fmt.Sprint(value)
+	}
+}
diff --git a/internal/pricing/catalog.go b/internal/pricing/catalog.go
index 73e2a7f..afd777e 100644
--- a/internal/pricing/catalog.go
+++ b/internal/pricing/catalog.go
@@ -21,10 +21,11 @@ const MaxCatalogBytes = 256 << 10
 var modelIDPattern = regexp.MustCompile(`^[a-z0-9][a-z0-9._-]{0,127}$`)
 
 type Rates struct {
-	Input       string  `json:"input"`
-	CachedInput *string `json:"cached_input"`
-	CacheWrite  *string `json:"cache_write"`
-	Output      string  `json:"output"`
+	CacheWrite1h *string `json:"cache_write_1h,omitempty"`
+	Input        string  `json:"input"`
+	CachedInput  *string `json:"cached_input"`
+	CacheWrite   *string `json:"cache_write"`
+	Output       string  `json:"output"`
 }
 
 type LongContext struct {
@@ -51,10 +52,11 @@ type Catalog struct {
 }
 
 type TokenRates struct {
-	Input       int64
-	CachedInput *int64
-	CacheWrite  *int64
-	Output      int64
+	CacheWrite1h *int64
+	Input        int64
+	CachedInput  *int64
+	CacheWrite   *int64
+	Output       int64
 }
 
 type Selected struct {
@@ -112,11 +114,14 @@ func Parse(data []byte) (Catalog, error) {
 	if decoder.Decode(new(any)) != io.EOF {
 		return Catalog{}, errors.New("pricing catalog has trailing data")
 	}
-	if catalog.SchemaVersion != 1 || catalog.CatalogVersion <= 0 || len(catalog.Entries) == 0 || len(catalog.Entries) > 2_000 {
+	if (catalog.SchemaVersion != 1 && catalog.SchemaVersion != 2) || catalog.CatalogVersion <= 0 || len(catalog.Entries) == 0 || len(catalog.Entries) > 2_000 {
 		return Catalog{}, errors.New("pricing catalog version or entries are invalid")
 	}
 	byModel := make(map[string][]Entry)
 	for _, entry := range catalog.Entries {
+		if catalog.SchemaVersion == 1 && (entry.ShortContext.CacheWrite1h != nil || entry.LongContext != nil && entry.LongContext.Rates.CacheWrite1h != nil) {
+			return Catalog{}, errors.New("pricing schema v1 does not support one-hour cache writes")
+		}
 		if err := validateEntry(entry); err != nil {
 			return Catalog{}, err
 		}
@@ -207,6 +212,13 @@ func parseRates(rates Rates) (TokenRates, error) {
 		}
 		selected.CacheWrite = &value
 	}
+	if rates.CacheWrite1h != nil {
+		value, err := decimalMicros(*rates.CacheWrite1h)
+		if err != nil {
+			return TokenRates{}, err
+		}
+		selected.CacheWrite1h = &value
+	}
 	return selected, nil
 }
 
diff --git a/internal/pricing/catalog_test.go b/internal/pricing/catalog_test.go
index 5bfa251..eed9a4e 100644
--- a/internal/pricing/catalog_test.go
+++ b/internal/pricing/catalog_test.go
@@ -60,7 +60,7 @@ func TestCatalogRejectsOverlappingPeriodsAndVersionRollback(t *testing.T) {
 	if _, err := Parse(data); err == nil {
 		t.Fatal("overlapping price periods accepted")
 	}
-	if err := catalog.ValidateCompatibleVersion(2); err == nil {
+	if err := catalog.ValidateCompatibleVersion(catalog.CatalogVersion + 1); err == nil {
 		t.Fatal("older catalog accepted")
 	}
 }
@@ -86,3 +86,33 @@ func TestCatalogRejectsUnknownFieldsAndUnsafeSource(t *testing.T) {
 		t.Fatal("unverified Grok Build model mapping accepted")
 	}
 }
+
+func TestLegacyCatalogDoesNotInferOneHourCacheRate(t *testing.T) {
+	catalog := Embedded()
+	catalog.SchemaVersion = 1
+	for i := range catalog.Entries {
+		catalog.Entries[i].ShortContext.CacheWrite1h = nil
+		if catalog.Entries[i].LongContext != nil {
+			catalog.Entries[i].LongContext.Rates.CacheWrite1h = nil
+		}
+	}
+	data, err := json.Marshal(catalog)
+	if err != nil {
+		t.Fatal(err)
+	}
+	legacy, err := Parse(data)
+	if err != nil {
+		t.Fatal(err)
+	}
+	at, _ := time.Parse("2006-01-02", "2026-09-24")
+	selected, ok := legacy.Select("claude-code", "claude-opus-5-5", at.UnixMilli())
+	if !ok || selected.Rates.CacheWrite == nil || *selected.Rates.CacheWrite != 5_000_000 || selected.Rates.CacheWrite1h != nil {
+		t.Fatalf("legacy rates: %+v", selected.Rates)
+	}
+	rate := "8"
+	catalog.Entries[0].ShortContext.CacheWrite1h = &rate
+	data, _ = json.Marshal(catalog)
+	if _, err := Parse(data); err == nil {
+		t.Fatal("v1 accepted one-hour rate")
+	}
+}
diff --git a/internal/pricing/service_test.go b/internal/pricing/service_test.go
index 707470a..541b6d6 100644
--- a/internal/pricing/service_test.go
+++ b/internal/pricing/service_test.go
@@ -50,18 +50,18 @@ func TestPricingCheckAcceptsNewCatalogAndKeepsItOnInvalidFeed(t *testing.T) {
 		return &http.Response{StatusCode: http.StatusOK, Body: io.NopCloser(bytes.NewReader(data)), Header: make(http.Header)}, nil
 	})
 	status, err := service.Check(ctx, true)
-	if err != nil || status.CatalogVersion != 2 || status.LastError != "" {
+	if err != nil || status.CatalogVersion != Embedded().CatalogVersion+1 || status.LastError != "" {
 		t.Fatalf("accepted status = %+v, err = %v", status, err)
 	}
 	service.client.Transport = roundTripFunc(func(*http.Request) (*http.Response, error) {
 		return &http.Response{StatusCode: http.StatusOK, Body: io.NopCloser(bytes.NewBufferString("{}")), Header: make(http.Header)}, nil
 	})
 	status, err = service.Check(ctx, true)
-	if err != nil || status.CatalogVersion != 2 || status.LastError != "invalid" {
+	if err != nil || status.CatalogVersion != Embedded().CatalogVersion+1 || status.LastError != "invalid" {
 		t.Fatalf("rejected status = %+v, err = %v", status, err)
 	}
 	snapshot, err := service.Snapshot(ctx)
-	if err != nil || snapshot.CatalogVersion != 2 {
+	if err != nil || snapshot.CatalogVersion != Embedded().CatalogVersion+1 {
 		t.Fatalf("retained snapshot = %+v, err = %v", snapshot, err)
 	}
 }
@@ -87,7 +87,7 @@ func TestPricingAutomaticCheckCanBeDisabled(t *testing.T) {
 	requestCtx, cancel := context.WithTimeout(ctx, 10*time.Millisecond)
 	defer cancel()
 	_, _ = service.Check(requestCtx, true)
-	if snapshot, err := service.Snapshot(ctx); err != nil || snapshot.CatalogVersion != 1 {
+	if snapshot, err := service.Snapshot(ctx); err != nil || snapshot.CatalogVersion != Embedded().CatalogVersion {
 		t.Fatalf("fallback after timeout = %+v, err = %v", snapshot, err)
 	}
 }
@@ -96,7 +96,7 @@ func TestPricingCheckRejectsRollbackAndChangedSameVersion(t *testing.T) {
 	ctx := context.Background()
 	service := pricingTestService(t)
 	catalog := Embedded()
-	catalog.CatalogVersion = 2
+	catalog.CatalogVersion = Embedded().CatalogVersion + 1
 	feed, err := json.Marshal(catalog)
 	if err != nil {
 		t.Fatal(err)
@@ -104,16 +104,16 @@ func TestPricingCheckRejectsRollbackAndChangedSameVersion(t *testing.T) {
 	service.client.Transport = roundTripFunc(func(*http.Request) (*http.Response, error) {
 		return &http.Response{StatusCode: http.StatusOK, Body: io.NopCloser(bytes.NewReader(feed)), Header: make(http.Header)}, nil
 	})
-	if status, err := service.Check(ctx, true); err != nil || status.CatalogVersion != 2 {
+	if status, err := service.Check(ctx, true); err != nil || status.CatalogVersion != Embedded().CatalogVersion+1 {
 		t.Fatalf("initial update = %+v, err = %v", status, err)
 	}
 	feed = marshalCatalog(t, Embedded())
-	if status, err := service.Check(ctx, true); err != nil || status.CatalogVersion != 2 || status.LastError != "invalid" {
+	if status, err := service.Check(ctx, true); err != nil || status.CatalogVersion != Embedded().CatalogVersion+1 || status.LastError != "invalid" {
 		t.Fatalf("rollback = %+v, err = %v", status, err)
 	}
 	catalog.Entries[0].ShortContext.Input = "999"
 	feed = marshalCatalog(t, catalog)
-	if status, err := service.Check(ctx, true); err != nil || status.CatalogVersion != 2 || status.LastError != "invalid" {
+	if status, err := service.Check(ctx, true); err != nil || status.CatalogVersion != Embedded().CatalogVersion+1 || status.LastError != "invalid" {
 		t.Fatalf("same-version modification = %+v, err = %v", status, err)
 	}
 }
@@ -125,7 +125,8 @@ func TestPricingUnreadableSavedCatalogKeepsSyncAvailableAndCanRecover(t *testing
 	if err != nil {
 		t.Fatal(err)
 	}
-	corrupt := state{Catalog: json.RawMessage(`{"catalog_version":2,"entries":"unreadable"}`)}
+	corruptData, _ := json.Marshal(map[string]any{"catalog_version": Embedded().CatalogVersion + 1, "entries": "unreadable"})
+	corrupt := state{Catalog: corruptData}
 	if err := writeState(ctx, db, corrupt); err != nil {
 		t.Fatal(err)
 	}
@@ -146,12 +147,12 @@ func TestPricingUnreadableSavedCatalogKeepsSyncAvailableAndCanRecover(t *testing
 		t.Fatalf("older feed replaced unreadable accepted version: %+v, err = %v", status, err)
 	}
 	version2 := Embedded()
-	version2.CatalogVersion = 2
+	version2.CatalogVersion = Embedded().CatalogVersion + 1
 	feed = marshalCatalog(t, version2)
 	service.client.Transport = roundTripFunc(func(*http.Request) (*http.Response, error) {
 		return &http.Response{StatusCode: http.StatusOK, Body: io.NopCloser(bytes.NewReader(feed)), Header: make(http.Header)}, nil
 	})
-	if status, err := service.Check(ctx, true); err != nil || status.CatalogVersion != 2 || status.LastError != "" || status.Automatic {
+	if status, err := service.Check(ctx, true); err != nil || status.CatalogVersion != Embedded().CatalogVersion+1 || status.LastError != "" || status.Automatic {
 		t.Fatalf("recovered status = %+v, err = %v", status, err)
 	}
 }
diff --git a/internal/store/integrity.go b/internal/store/integrity.go
index 75d8f62..a58f383 100644
--- a/internal/store/integrity.go
+++ b/internal/store/integrity.go
@@ -297,7 +297,27 @@ var schemaContracts = func() []schemaContract {
 	pricingCatalog := reportedCost
 	pricingCatalog.migrationKey = "pricing_catalog"
 	pricingCatalog.tableSpecs = replaceTableSpec(pricingCatalog.tableSpecs, pricingCatalogFactTableSpec)
-	return []schemaContract{stable, grokBuild, incremental, observationParserRevision, reportedCost, pricingCatalog}
+	claudeCode := pricingCatalog
+	claudeCode.migrationKey = "claude_code_usage"
+	claudeCode.tableSpecs = replaceTableSpec(claudeCode.tableSpecs, claudeCodeUsageFactTableSpec)
+	claudeCode.tableSpecs = append(append([]tableSpec(nil), claudeCode.tableSpecs...), claudeCodeUsageImportTableSpec)
+	claudeCode.jsonQueries = append(append([]string(nil), pricingCatalog.jsonQueries...), `SELECT COUNT(1) FROM usage_facts WHERE NOT (`+jsonObjectExpression("price_snapshot_json")+`)`, claudeCodeUsageDiagnosticsViolationQuery)
+	claudeCode.referenceQueries = append(append([]string(nil), pricingCatalog.referenceQueries...), `SELECT COUNT(1) FROM claude_code_usage_import_files AS value WHERE NOT EXISTS (SELECT 1 FROM usage_sources WHERE usage_sources.id = value.source_id AND usage_sources.provider_id = 'claude-code' AND usage_sources.identity_revision = value.identity_revision)`)
+	claudeCode.stateQueries = append(append([]string(nil), pricingCatalog.stateQueries...), `SELECT COUNT(1) FROM usage_facts AS f JOIN usage_sources AS s ON s.id=f.source_id WHERE (s.provider_id <> 'claude-code' AND (f.token_status <> 0 OR f.price_snapshot_json <> '{}' OR f.cache_write_5m_tokens IS NOT NULL OR f.cache_write_1h_tokens IS NOT NULL OR f.pricing_eligible <> 0)) OR (f.token_status IN (2,3) AND (f.input_tokens <> 0 OR f.cached_input_tokens <> 0 OR f.output_tokens <> 0 OR f.total_tokens <> 0 OR f.estimated_cost_micros IS NOT NULL))`, `SELECT COUNT(1) FROM claude_code_usage_import_files WHERE checkpoint_revision <> 1 OR metadata_digest=zeroblob(32) OR boundary_digest=zeroblob(32) OR checkpoint_event_digest=zeroblob(32)`)
+	claudeCode.stateQueries = append(claudeCode.stateQueries, `SELECT COUNT(1) FROM usage_facts AS f JOIN usage_sources AS s ON s.id=f.source_id WHERE s.provider_id='claude-code' AND (
+		(f.token_status=1 AND f.output_tokens<>0) OR
+		(f.cache_write_5m_tokens IS NULL)<>(f.cache_write_1h_tokens IS NULL) OR
+		(f.cache_write_5m_tokens IS NOT NULL AND (f.cache_creation_input_tokens IS NULL OR f.cache_write_5m_tokens>f.cache_creation_input_tokens OR f.cache_write_1h_tokens<>f.cache_creation_input_tokens-f.cache_write_5m_tokens)) OR
+		(f.cache_creation_input_tokens>f.input_tokens-f.cached_input_tokens) OR
+		(f.token_status IN (2,3) AND (f.cost_status<>0 OR f.pricing_eligible<>0 OR (f.token_status=3 AND f.price_snapshot_json<>'{}') OR f.cache_write_input_tokens IS NOT NULL OR f.cache_creation_input_tokens IS NOT NULL OR f.cache_write_5m_tokens IS NOT NULL OR f.cache_write_1h_tokens IS NOT NULL))
+	)`, `SELECT COUNT(1) FROM usage_facts AS f WHERE CASE WHEN json_valid(f.price_snapshot_json)=0 THEN 0 WHEN f.price_snapshot_json='{}' THEN 0 ELSE
+		COALESCE(json_type(f.price_snapshot_json,'$.version'),'')<>'integer' OR COALESCE(json_extract(f.price_snapshot_json,'$.version'),0)<=0 OR
+		COALESCE(json_type(f.price_snapshot_json,'$.input'),'')<>'integer' OR COALESCE(json_extract(f.price_snapshot_json,'$.input'),0) NOT BETWEEN 1 AND 1000000000 OR
+		COALESCE(json_type(f.price_snapshot_json,'$.output'),'')<>'integer' OR COALESCE(json_extract(f.price_snapshot_json,'$.output'),0) NOT BETWEEN 1 AND 1000000000 OR
+		COALESCE(json_type(f.price_snapshot_json,'$.model'),'')<>'text' OR length(COALESCE(json_extract(f.price_snapshot_json,'$.model'),'')) NOT BETWEEN 1 AND 200 OR json_extract(f.price_snapshot_json,'$.model') GLOB '*[^a-zA-Z0-9._:/@-]*' OR
+		f.token_status=3 OR (f.token_status IN (0,1) AND (f.pricing_eligible<>1 OR f.estimated_cost_micros IS NULL)) OR COALESCE(f.pricing_catalog_version,0)<>json_extract(f.price_snapshot_json,'$.version') OR
+		EXISTS (SELECT 1 FROM json_each(f.price_snapshot_json) WHERE key NOT IN ('model','version','input','output','cached_input','cache_write_5m','cache_write_1h') OR (key IN ('cached_input','cache_write_5m','cache_write_1h') AND (type<>'integer' OR value NOT BETWEEN 1 AND 1000000000))) END`)
+	return []schemaContract{stable, grokBuild, incremental, observationParserRevision, reportedCost, pricingCatalog, claudeCode}
 }()
 
 func jsonObjectExpression(column string) string {
diff --git a/internal/store/migrations/202609280001_claude_code_usage.go b/internal/store/migrations/202609280001_claude_code_usage.go
new file mode 100644
index 0000000..555c365
--- /dev/null
+++ b/internal/store/migrations/202609280001_claude_code_usage.go
@@ -0,0 +1,86 @@
+package migrations
+
+import (
+	"context"
+
+	"github.com/uptrace/bun"
+)
+
+func init() { Migrations.MustRegister(upClaudeCodeUsage, downClaudeCodeUsage) }
+func upClaudeCodeUsage(ctx context.Context, db *bun.DB) error {
+	return db.RunInTx(ctx, nil, func(ctx context.Context, tx bun.Tx) error {
+		if err := addUsageColumnIfMissing(ctx, tx, "usage_facts", "token_status", "INTEGER NOT NULL DEFAULT 0 CHECK (token_status BETWEEN 0 AND 3)"); err != nil {
+			return err
+		}
+		if err := addUsageColumnIfMissing(ctx, tx, "usage_facts", "cache_write_5m_tokens", "INTEGER CHECK (cache_write_5m_tokens IS NULL OR cache_write_5m_tokens >= 0)"); err != nil {
+			return err
+		}
+		if err := addUsageColumnIfMissing(ctx, tx, "usage_facts", "cache_write_1h_tokens", "INTEGER CHECK (cache_write_1h_tokens IS NULL OR cache_write_1h_tokens >= 0)"); err != nil {
+			return err
+		}
+		if err := addUsageColumnIfMissing(ctx, tx, "usage_facts", "pricing_eligible", "INTEGER NOT NULL DEFAULT 0 CHECK (pricing_eligible IN (0, 1))"); err != nil {
+			return err
+		}
+		if err := addUsageColumnIfMissing(ctx, tx, "usage_facts", "price_snapshot_json", "TEXT NOT NULL DEFAULT '{}' CHECK (CASE WHEN json_valid(price_snapshot_json) THEN json_type(price_snapshot_json) = 'object' AND length(CAST(price_snapshot_json AS BLOB)) <= 1024 ELSE 0 END)"); err != nil {
+			return err
+		}
+		_, err := tx.ExecContext(ctx, `CREATE TABLE IF NOT EXISTS claude_code_usage_import_files (
+			source_id INTEGER NOT NULL,
+			file_key BLOB NOT NULL CHECK (
+				typeof(file_key) = 'blob' AND length(file_key) = 32 AND file_key <> zeroblob(32)
+			),
+			modified_unix_ms INTEGER NOT NULL DEFAULT 0 CHECK (modified_unix_ms >= 0),
+			size_bytes INTEGER NOT NULL DEFAULT 0 CHECK (size_bytes >= 0),
+			imported_facts INTEGER NOT NULL DEFAULT 0 CHECK (imported_facts >= 0),
+			invalid_lines INTEGER NOT NULL DEFAULT 0 CHECK (invalid_lines >= 0),
+			unsupported_lines INTEGER NOT NULL DEFAULT 0 CHECK (unsupported_lines >= 0),
+			parser_revision INTEGER NOT NULL CHECK (parser_revision > 0),
+			identity_revision INTEGER NOT NULL CHECK (identity_revision > 0),
+			event_digest BLOB NOT NULL CHECK (
+				typeof(event_digest) = 'blob' AND length(event_digest) = 32 AND event_digest <> zeroblob(32)
+			),
+			checkpoint_revision INTEGER NOT NULL DEFAULT 0 CHECK (checkpoint_revision >= 0),
+			processed_bytes INTEGER NOT NULL DEFAULT 0 CHECK (processed_bytes >= 0 AND processed_bytes <= size_bytes),
+			metadata_digest BLOB NOT NULL DEFAULT X'0000000000000000000000000000000000000000000000000000000000000000' CHECK (typeof(metadata_digest) = 'blob' AND length(metadata_digest) = 32),
+			file_identity_digest BLOB NOT NULL DEFAULT X'0000000000000000000000000000000000000000000000000000000000000000' CHECK (typeof(file_identity_digest) = 'blob' AND length(file_identity_digest) = 32),
+			boundary_digest BLOB NOT NULL DEFAULT X'0000000000000000000000000000000000000000000000000000000000000000' CHECK (typeof(boundary_digest) = 'blob' AND length(boundary_digest) = 32),
+			checkpoint_event_digest BLOB NOT NULL DEFAULT X'0000000000000000000000000000000000000000000000000000000000000000' CHECK (typeof(checkpoint_event_digest) = 'blob' AND length(checkpoint_event_digest) = 32),
+			parser_state_json TEXT NOT NULL DEFAULT '{}' CHECK (CASE WHEN json_valid(parser_state_json) THEN json_type(parser_state_json) = 'object' AND length(CAST(parser_state_json AS BLOB)) <= 1048576 ELSE 0 END),
+			updated_at_unix_ms INTEGER NOT NULL CHECK (updated_at_unix_ms >= 0),
+			PRIMARY KEY (source_id, file_key),
+			FOREIGN KEY (source_id) REFERENCES usage_sources(id)
+				ON UPDATE RESTRICT ON DELETE CASCADE
+		) STRICT, WITHOUT ROWID`)
+		if err != nil {
+			return err
+		}
+		_, err = tx.ExecContext(ctx, `SELECT file_key, checkpoint_revision, processed_bytes, metadata_digest,
+			file_identity_digest, boundary_digest, checkpoint_event_digest, parser_state_json
+			FROM claude_code_usage_import_files LIMIT 0`)
+		return err
+	})
+}
+
+func downClaudeCodeUsage(ctx context.Context, db *bun.DB) error {
+	return db.RunInTx(ctx, nil, func(ctx context.Context, tx bun.Tx) error {
+		if _, err := tx.ExecContext(ctx, `DROP TABLE IF EXISTS claude_code_usage_import_files`); err != nil {
+			return err
+		}
+		if err := dropUsageColumnIfExists(ctx, tx, "usage_facts", "price_snapshot_json"); err != nil {
+			return err
+		}
+		if err := dropUsageColumnIfExists(ctx, tx, "usage_facts", "pricing_eligible"); err != nil {
+			return err
+		}
+		if err := dropUsageColumnIfExists(ctx, tx, "usage_facts", "cache_write_1h_tokens"); err != nil {
+			return err
+		}
+		if err := dropUsageColumnIfExists(ctx, tx, "usage_facts", "cache_write_5m_tokens"); err != nil {
+			return err
+		}
+		if err := dropUsageColumnIfExists(ctx, tx, "usage_facts", "token_status"); err != nil {
+			return err
+		}
+		return nil
+	})
+}
diff --git a/internal/store/migrations/migrations_test.go b/internal/store/migrations/migrations_test.go
index 93e03f0..884245f 100644
--- a/internal/store/migrations/migrations_test.go
+++ b/internal/store/migrations/migrations_test.go
@@ -310,3 +310,28 @@ func TestGrokBuildReportedCostUpgradeIsReplaySafeAndReversible(t *testing.T) {
 		}
 	}
 }
+
+func TestClaudeCodeUsageMigrationRollsBackAddedColumns(t *testing.T) {
+	ctx := context.Background()
+	sqlDB, err := sql.Open("sqlite", filepath.Join(t.TempDir(), "migration.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	db := bun.NewDB(sqlDB, sqlitedialect.New())
+	defer db.Close()
+	if err := upStableBaseline(ctx, db); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := sqlDB.ExecContext(ctx, `CREATE VIEW claude_code_usage_import_files AS SELECT 1 AS source_id`); err != nil {
+		t.Fatal(err)
+	}
+	if err := upClaudeCodeUsage(ctx, db); err == nil {
+		t.Fatal("migration accepted incompatible checkpoint object")
+	}
+	for _, column := range []string{"token_status", "cache_write_5m_tokens", "cache_write_1h_tokens", "pricing_eligible", "price_snapshot_json"} {
+		exists, err := usageColumnExists(ctx, db, "usage_facts", column)
+		if err != nil || exists {
+			t.Fatalf("failed migration retained %s: %t, %v", column, exists, err)
+		}
+	}
+}
diff --git a/internal/store/schema_contract.go b/internal/store/schema_contract.go
index f534f77..c3aefd05 100644
--- a/internal/store/schema_contract.go
+++ b/internal/store/schema_contract.go
@@ -603,3 +603,24 @@ var stableBaselineTriggerSpecs = []triggerSpec{
 		},
 	},
 }
+
+var claudeCodeUsageImportTableSpec = func() tableSpec {
+	spec := copyTableSpec(usageIncrementalGrokBuildImportTableSpec)
+	spec.name = "claude_code_usage_import_files"
+	return spec
+}()
+
+var claudeCodeUsageFactTableSpec = func() tableSpec {
+	spec := copyTableSpec(pricingCatalogFactTableSpec)
+	spec.columns = append(spec.columns, columnSpec{name: "token_status", columnType: "INTEGER", notNull: true, requireDefault: true, defaultValue: "0"})
+	spec.checks = append(spec.checks, `CHECK (token_status BETWEEN 0 AND 3)`)
+	spec.columns = append(spec.columns, columnSpec{name: "cache_write_5m_tokens", columnType: "INTEGER"})
+	spec.checks = append(spec.checks, `CHECK (cache_write_5m_tokens IS NULL OR cache_write_5m_tokens >= 0)`)
+	spec.columns = append(spec.columns, columnSpec{name: "cache_write_1h_tokens", columnType: "INTEGER"})
+	spec.checks = append(spec.checks, `CHECK (cache_write_1h_tokens IS NULL OR cache_write_1h_tokens >= 0)`)
+	spec.columns = append(spec.columns, columnSpec{name: "pricing_eligible", columnType: "INTEGER", notNull: true, requireDefault: true, defaultValue: "0"})
+	spec.checks = append(spec.checks, `CHECK (pricing_eligible IN (0, 1))`)
+	spec.columns = append(spec.columns, columnSpec{name: "price_snapshot_json", columnType: "TEXT", notNull: true, requireDefault: true, defaultValue: "'{}'"})
+	spec.checks = append(spec.checks, `CHECK (CASE WHEN json_valid(price_snapshot_json) THEN json_type(price_snapshot_json) = 'object' AND length(CAST(price_snapshot_json AS BLOB)) <= 1024 ELSE 0 END)`)
+	return spec
+}()
diff --git a/internal/store/store_test.go b/internal/store/store_test.go
index f1d6ed3..e98f22f 100644
--- a/internal/store/store_test.go
+++ b/internal/store/store_test.go
@@ -254,11 +254,14 @@ func TestAppliedSchemaUsesItsVersionedContract(t *testing.T) {
 	if _, err := db.db.DB.ExecContext(ctx, `ALTER TABLE usage_sources DROP COLUMN completed_generation`); err != nil {
 		t.Fatalf("remove usage completion generation: %v", err)
 	}
-	for _, column := range []string{"cache_creation_input_tokens", "cache_write_input_tokens", "pricing_catalog_version", "reported_cost_status", "reported_cost_usd_ticks"} {
+	for _, column := range []string{"price_snapshot_json", "pricing_eligible", "cache_write_1h_tokens", "cache_write_5m_tokens", "token_status", "cache_creation_input_tokens", "cache_write_input_tokens", "pricing_catalog_version", "reported_cost_status", "reported_cost_usd_ticks"} {
 		if _, err := db.db.DB.ExecContext(ctx, fmt.Sprintf("ALTER TABLE usage_facts DROP COLUMN %s", column)); err != nil {
 			t.Fatalf("remove reported usage cost column %s: %v", column, err)
 		}
 	}
+	if _, err := db.db.DB.ExecContext(ctx, `DROP TABLE claude_code_usage_import_files`); err != nil {
+		t.Fatal(err)
+	}
 	if _, err := db.db.DB.ExecContext(ctx, `DROP TABLE grok_build_usage_import_files`); err != nil {
 		t.Fatalf("restore unmarked Stable schema: %v", err)
 	}
diff --git a/internal/store/usage.go b/internal/store/usage.go
index 6c31db7..1ed952b 100644
--- a/internal/store/usage.go
+++ b/internal/store/usage.go
@@ -129,7 +129,31 @@ type UsageSource struct {
 	UnsupportedRecords    int64
 }
 
+type UsageTokenStatus int64
+
+const (
+	UsageTokensComplete UsageTokenStatus = iota
+	UsageTokensPartial
+	UsageTokensPartialConflict
+	UsageTokensFinalConflict
+)
+
+type UsagePriceSnapshot struct {
+	ModelKey     string `json:"model"`
+	Version      int64  `json:"version"`
+	Input        int64  `json:"input"`
+	CachedInput  *int64 `json:"cached_input,omitempty"`
+	CacheWrite5m *int64 `json:"cache_write_5m,omitempty"`
+	CacheWrite1h *int64 `json:"cache_write_1h,omitempty"`
+	Output       int64  `json:"output"`
+}
+
 type CreateUsageFactParams struct {
+	TokenStatus              UsageTokenStatus
+	CacheWrite5mTokens       *int64
+	CacheWrite1hTokens       *int64
+	PricingEligible          bool
+	PriceSnapshot            *UsagePriceSnapshot
 	EventKey                 UsageKey
 	SourceID                 int64
 	SessionKey               string
@@ -149,6 +173,7 @@ type CreateUsageFactParams struct {
 }
 
 type UsageInsertResult struct {
+	Updated    int
 	Inserted   int
 	Duplicates int
 }
@@ -1060,6 +1085,7 @@ func (s *Store) ListUnknownUsageCostModels(ctx context.Context, providerID strin
 			SELECT 1
 			FROM usage_facts f INDEXED BY idx_usage_facts_source_cost_model_id
 			WHERE f.source_id = m.source_id AND f.cost_status = ? AND f.model_id = m.id
+ AND (s.provider_id <> 'claude-code' OR (f.pricing_eligible=1 AND f.token_status IN (0,1)))
 			LIMIT 1
 		)
 		ORDER BY m.source_id ASC, m.id ASC
@@ -1087,9 +1113,11 @@ func (s *Store) HasUnknownUsageFactCostInPeriod(ctx context.Context, sourceID, m
 	var found int
 	err := s.executor().QueryRowContext(ctx, `
 		SELECT EXISTS (
-			SELECT 1 FROM usage_facts INDEXED BY idx_usage_facts_source_cost_model_id
-			WHERE source_id = ? AND cost_status = ? AND model_id = ?
-				AND occurred_at_unix_ms >= ? AND occurred_at_unix_ms < ?
+			SELECT 1 FROM usage_facts f INDEXED BY idx_usage_facts_source_cost_model_id
+			JOIN usage_sources s ON s.id = f.source_id
+			WHERE f.source_id = ? AND f.cost_status = ? AND f.model_id = ?
+				AND f.occurred_at_unix_ms >= ? AND f.occurred_at_unix_ms < ?
+				AND (s.provider_id <> 'claude-code' OR (f.pricing_eligible=1 AND f.token_status IN (0,1)))
 			LIMIT 1
 		)
 	`, sourceID, UsageCostStatusUnknown, modelID, fromUnixMS, untilUnixMS).Scan(&found)
diff --git a/internal/store/usage_claude_code.go b/internal/store/usage_claude_code.go
new file mode 100644
index 0000000..bc2cae1
--- /dev/null
+++ b/internal/store/usage_claude_code.go
@@ -0,0 +1,475 @@
+package store
+
+import (
+	"context"
+	"crypto/sha256"
+	"database/sql"
+	"encoding/hex"
+	"errors"
+	"strings"
+	"time"
+)
+
+type ClaudeCodeUsageImportFile struct {
+	SourceID              int64
+	FileKey               UsageKey
+	ModifiedUnixMS        int64
+	SizeBytes             int64
+	ImportedFacts         int64
+	InvalidLines          int64
+	UnsupportedLines      int64
+	ParserRevision        int64
+	IdentityRevision      int64
+	EventDigest           UsageKey
+	CheckpointRevision    int64
+	ProcessedBytes        int64
+	MetadataDigest        UsageKey
+	FileIdentityDigest    UsageKey
+	BoundaryDigest        UsageKey
+	CheckpointEventDigest UsageKey
+	ParserStateJSON       string
+	UpdatedAtUnixMS       int64
+}
+
+type CommitClaudeCodeUsageImportParams struct {
+	ProviderID          string
+	Generation          int64
+	Facts               []CreateUsageFactParams
+	File                ClaudeCodeUsageImportFile
+	Expected            *ClaudeCodeUsageImportFile
+	ReplayExistingFacts bool
+	Price               ClaudeCodeUsagePricer
+}
+
+type ClaudeCodeUsageSyncFinalization struct {
+	ProviderID         string
+	DiscoveredFileKeys []UsageKey
+}
+
+func (finalization *ClaudeCodeUsageSyncFinalization) validateUsageSyncFinalization() error {
+	if finalization == nil || strings.TrimSpace(finalization.ProviderID) == "" {
+		return errors.New("invalid Claude Code usage sync finalization")
+	}
+	for _, fileKey := range finalization.DiscoveredFileKeys {
+		if fileKey.IsZero() {
+			return errors.New("invalid Claude Code usage sync finalization")
+		}
+	}
+	return nil
+}
+
+// ValidateClaudeCodeUsageImportIdentity rejects checkpoints produced under
+// another fact identity revision.
+func (s *Store) ValidateClaudeCodeUsageImportIdentity(
+	ctx context.Context,
+	sourceID int64,
+	providerID string,
+	identityRevision int64,
+) error {
+	providerID = strings.TrimSpace(providerID)
+	if sourceID <= 0 || providerID == "" || identityRevision <= 0 {
+		return errors.New("invalid Claude Code usage import identity")
+	}
+	source, err := s.getUsageSourceByID(ctx, sourceID)
+	if err != nil {
+		return err
+	}
+	if source.ProviderID != providerID {
+		return errors.New("invalid Claude Code usage import source")
+	}
+	if source.IdentityRevision != identityRevision {
+		return ErrUsageIdentityRevision
+	}
+	var incompatibleFiles int
+	if err := s.executor().QueryRowContext(ctx, `
+		SELECT COUNT(1)
+		FROM claude_code_usage_import_files
+		WHERE source_id = ? AND identity_revision <> ?
+	`, source.ID, identityRevision).Scan(&incompatibleFiles); err != nil {
+		return err
+	}
+	if incompatibleFiles > 0 {
+		return ErrUsageIdentityRevision
+	}
+	return nil
+}
+
+func (s *Store) GetClaudeCodeUsageImportFile(
+	ctx context.Context,
+	sourceID int64,
+	fileKey UsageKey,
+) (ClaudeCodeUsageImportFile, error) {
+	row := s.executor().QueryRowContext(ctx, `
+		SELECT source_id, file_key, modified_unix_ms, size_bytes, imported_facts,
+			invalid_lines, unsupported_lines, parser_revision, identity_revision,
+			event_digest, checkpoint_revision, processed_bytes, metadata_digest,
+			file_identity_digest, boundary_digest, checkpoint_event_digest,
+			parser_state_json, updated_at_unix_ms
+		FROM claude_code_usage_import_files
+		WHERE source_id = ? AND file_key = ?
+	`, sourceID, fileKey)
+	cursor, err := scanClaudeCodeUsageImportFile(row)
+	if errors.Is(err, sql.ErrNoRows) {
+		return ClaudeCodeUsageImportFile{}, ErrNotFound
+	}
+	return cursor, err
+}
+
+func (s *Store) ListClaudeCodeUsageImportFiles(
+	ctx context.Context,
+	sourceID int64,
+) ([]ClaudeCodeUsageImportFile, error) {
+	if sourceID <= 0 {
+		return nil, errors.New("invalid Claude Code usage import query")
+	}
+	rows, err := s.executor().QueryContext(ctx, `
+		SELECT source_id, file_key, modified_unix_ms, size_bytes, imported_facts,
+			invalid_lines, unsupported_lines, parser_revision, identity_revision,
+			event_digest, checkpoint_revision, processed_bytes, metadata_digest,
+			file_identity_digest, boundary_digest, checkpoint_event_digest,
+			parser_state_json, updated_at_unix_ms
+		FROM claude_code_usage_import_files
+		WHERE source_id = ?
+		ORDER BY file_key
+	`, sourceID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	files := make([]ClaudeCodeUsageImportFile, 0)
+	for rows.Next() {
+		file, err := scanClaudeCodeUsageImportFile(rows)
+		if err != nil {
+			return nil, err
+		}
+		files = append(files, file)
+	}
+	return files, rows.Err()
+}
+
+func scanClaudeCodeUsageImportFile(row rowScanner) (ClaudeCodeUsageImportFile, error) {
+	var cursor ClaudeCodeUsageImportFile
+	if err := row.Scan(
+		&cursor.SourceID,
+		&cursor.FileKey,
+		&cursor.ModifiedUnixMS,
+		&cursor.SizeBytes,
+		&cursor.ImportedFacts,
+		&cursor.InvalidLines,
+		&cursor.UnsupportedLines,
+		&cursor.ParserRevision,
+		&cursor.IdentityRevision,
+		&cursor.EventDigest,
+		&cursor.CheckpointRevision,
+		&cursor.ProcessedBytes,
+		&cursor.MetadataDigest,
+		&cursor.FileIdentityDigest,
+		&cursor.BoundaryDigest,
+		&cursor.CheckpointEventDigest,
+		&cursor.ParserStateJSON,
+		&cursor.UpdatedAtUnixMS,
+	); err != nil {
+		return ClaudeCodeUsageImportFile{}, err
+	}
+	return cursor, nil
+}
+
+func (s *Store) CommitClaudeCodeUsageImport(
+	ctx context.Context,
+	params CommitClaudeCodeUsageImportParams,
+) (UsageInsertResult, error) {
+	if err := validateClaudeCodeUsageImportBatch(params); err != nil {
+		return UsageInsertResult{}, err
+	}
+	// Facts and the file checkpoint share one transaction so quarantined or
+	// interrupted files never advance past facts that were not stored.
+	return withUsageTransactionResult(ctx, s, func(txStore *Store) (UsageInsertResult, error) {
+		return txStore.commitClaudeCodeUsageImport(ctx, params)
+	})
+}
+
+func (s *Store) commitClaudeCodeUsageImport(
+	ctx context.Context,
+	params CommitClaudeCodeUsageImportParams,
+) (UsageInsertResult, error) {
+	source, err := s.reserveCurrentUsageSyncForWrite(ctx, params.File.SourceID, params.Generation)
+	if err != nil {
+		return UsageInsertResult{}, err
+	}
+	if source.ProviderID != params.ProviderID {
+		return UsageInsertResult{}, errors.New("invalid Claude Code usage import source")
+	}
+	result, err := s.reconcileClaudeCodeUsageFacts(ctx, params.Facts, params.Price)
+	if err != nil {
+		return UsageInsertResult{}, err
+	}
+	if err := s.upsertClaudeCodeUsageImportFileCAS(ctx, params.File, params.Expected); err != nil {
+		return UsageInsertResult{}, err
+	}
+	if err := s.deleteUsageImportObservation(ctx, params.File.SourceID, params.File.FileKey); err != nil {
+		return UsageInsertResult{}, err
+	}
+	return result, nil
+}
+
+func validateClaudeCodeUsageImportBatch(params CommitClaudeCodeUsageImportParams) error {
+	if params.ProviderID != "claude-code" || params.Generation <= 0 {
+		return errors.New("invalid Claude Code usage sync generation")
+	}
+	if err := validateClaudeCodeUsageImportFile(params.File); err != nil {
+		return err
+	}
+	for _, fact := range params.Facts {
+		if fact.SourceID != params.File.SourceID {
+			return errors.New("usage facts must belong to the Claude Code import source")
+		}
+		// Reject direct upstream identifiers at the persistence boundary so a
+		// future importer cannot accidentally bypass the session privacy contract.
+		if !validClaudeCodeDerivedSessionKey(fact.SessionKey) {
+			return errors.New("usage sessions for Claude Code must use derived identifiers")
+		}
+	}
+	if params.Expected == nil {
+		if params.File.ImportedFacts != int64(len(params.Facts)) {
+			return errors.New("usage import progress does not match its Claude Code facts")
+		}
+		return nil
+	}
+	if err := validateClaudeCodeUsageImportFile(*params.Expected); err != nil {
+		return err
+	}
+	if params.ReplayExistingFacts {
+		if params.File.ParserRevision < params.Expected.ParserRevision ||
+			params.File.ImportedFacts < params.Expected.ImportedFacts ||
+			params.File.ImportedFacts != int64(len(params.Facts)) {
+			return errors.New("invalid Claude Code usage fact replay")
+		}
+		return nil
+	}
+	if params.File.ImportedFacts < params.Expected.ImportedFacts ||
+		params.File.ImportedFacts-params.Expected.ImportedFacts != int64(len(params.Facts)) {
+		return errors.New("usage import progress does not match its Claude Code facts")
+	}
+	return nil
+}
+
+func validClaudeCodeDerivedSessionKey(value string) bool {
+	const prefix = "derived-"
+	if len(value) != len(prefix)+hex.EncodedLen(sha256.Size) ||
+		!strings.HasPrefix(value, prefix) {
+		return false
+	}
+	encoded := strings.TrimPrefix(value, prefix)
+	if encoded != strings.ToLower(encoded) {
+		return false
+	}
+	_, err := hex.DecodeString(encoded)
+	return err == nil
+}
+
+func (s *Store) upsertClaudeCodeUsageImportFileCAS(
+	ctx context.Context,
+	file ClaudeCodeUsageImportFile,
+	expected *ClaudeCodeUsageImportFile,
+) error {
+	if err := validateClaudeCodeUsageImportFile(file); err != nil {
+		return err
+	}
+	if file.CheckpointRevision == 0 && strings.TrimSpace(file.ParserStateJSON) == "" {
+		file.ParserStateJSON = "{}"
+	}
+	source, err := s.getUsageSourceByID(ctx, file.SourceID)
+	if err != nil {
+		return err
+	}
+	if source.IdentityRevision != file.IdentityRevision {
+		return ErrUsageIdentityRevision
+	}
+
+	updatedAt := time.Now().UnixMilli()
+	if expected == nil {
+		_, err := s.executor().ExecContext(ctx, `
+			INSERT INTO claude_code_usage_import_files (
+				source_id, file_key, modified_unix_ms, size_bytes, imported_facts,
+				invalid_lines, unsupported_lines, parser_revision, identity_revision,
+				event_digest, checkpoint_revision, processed_bytes, metadata_digest,
+				file_identity_digest, boundary_digest, checkpoint_event_digest,
+				parser_state_json, updated_at_unix_ms
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+		`,
+			file.SourceID,
+			file.FileKey,
+			file.ModifiedUnixMS,
+			file.SizeBytes,
+			file.ImportedFacts,
+			file.InvalidLines,
+			file.UnsupportedLines,
+			file.ParserRevision,
+			file.IdentityRevision,
+			file.EventDigest,
+			file.CheckpointRevision,
+			file.ProcessedBytes,
+			file.MetadataDigest,
+			file.FileIdentityDigest,
+			file.BoundaryDigest,
+			file.CheckpointEventDigest,
+			file.ParserStateJSON,
+			updatedAt,
+		)
+		if isSQLiteConstraintError(err) {
+			return ErrUsageCursorConflict
+		}
+		return err
+	}
+	if expected.SourceID != file.SourceID || expected.FileKey != file.FileKey {
+		return ErrUsageCursorConflict
+	}
+	if updatedAt <= expected.UpdatedAtUnixMS {
+		updatedAt = expected.UpdatedAtUnixMS + 1
+	}
+	update, err := s.executor().ExecContext(ctx, `
+		UPDATE claude_code_usage_import_files
+		SET modified_unix_ms = ?, size_bytes = ?, imported_facts = ?,
+			invalid_lines = ?, unsupported_lines = ?, parser_revision = ?,
+			identity_revision = ?, event_digest = ?, checkpoint_revision = ?,
+			processed_bytes = ?, metadata_digest = ?, file_identity_digest = ?,
+			boundary_digest = ?, checkpoint_event_digest = ?, parser_state_json = ?,
+			updated_at_unix_ms = ?
+		WHERE source_id = ? AND file_key = ?
+			AND modified_unix_ms = ? AND size_bytes = ? AND imported_facts = ?
+			AND invalid_lines = ? AND unsupported_lines = ? AND parser_revision = ?
+			AND identity_revision = ? AND event_digest = ? AND checkpoint_revision = ?
+			AND processed_bytes = ? AND metadata_digest = ? AND file_identity_digest = ?
+			AND boundary_digest = ? AND checkpoint_event_digest = ? AND parser_state_json = ?
+			AND updated_at_unix_ms = ?
+	`,
+		file.ModifiedUnixMS,
+		file.SizeBytes,
+		file.ImportedFacts,
+		file.InvalidLines,
+		file.UnsupportedLines,
+		file.ParserRevision,
+		file.IdentityRevision,
+		file.EventDigest,
+		file.CheckpointRevision,
+		file.ProcessedBytes,
+		file.MetadataDigest,
+		file.FileIdentityDigest,
+		file.BoundaryDigest,
+		file.CheckpointEventDigest,
+		file.ParserStateJSON,
+		updatedAt,
+		file.SourceID,
+		file.FileKey,
+		expected.ModifiedUnixMS,
+		expected.SizeBytes,
+		expected.ImportedFacts,
+		expected.InvalidLines,
+		expected.UnsupportedLines,
+		expected.ParserRevision,
+		expected.IdentityRevision,
+		expected.EventDigest,
+		expected.CheckpointRevision,
+		expected.ProcessedBytes,
+		expected.MetadataDigest,
+		expected.FileIdentityDigest,
+		expected.BoundaryDigest,
+		expected.CheckpointEventDigest,
+		expected.ParserStateJSON,
+		expected.UpdatedAtUnixMS,
+	)
+	if err != nil {
+		return err
+	}
+	rows, err := update.RowsAffected()
+	if err != nil {
+		return err
+	}
+	if rows != 1 {
+		return ErrUsageCursorConflict
+	}
+	return nil
+}
+
+func validateClaudeCodeUsageImportFile(file ClaudeCodeUsageImportFile) error {
+	if file.SourceID <= 0 || file.FileKey.IsZero() || file.EventDigest.IsZero() ||
+		file.ModifiedUnixMS < 0 || file.SizeBytes < 0 || file.ImportedFacts < 0 ||
+		file.InvalidLines < 0 || file.UnsupportedLines < 0 ||
+		file.ParserRevision <= 0 || file.IdentityRevision <= 0 ||
+		file.UpdatedAtUnixMS < 0 || file.CheckpointRevision != 1 ||
+		file.ProcessedBytes < 0 || file.ProcessedBytes > file.SizeBytes {
+		return errors.New("invalid Claude Code usage import file")
+	}
+	if file.CheckpointRevision != 1 || file.MetadataDigest.IsZero() ||
+		file.BoundaryDigest.IsZero() || file.CheckpointEventDigest.IsZero() {
+		return errors.New("invalid Claude Code checkpoint")
+	}
+	_, err := DecodeClaudeCodeUsageInvalidReasons(file.ParserStateJSON, file.InvalidLines)
+	return err
+}
+
+func (finalization *ClaudeCodeUsageSyncFinalization) applyUsageSyncFinalization(
+	ctx context.Context,
+	store *Store,
+	source UsageSource,
+) (usageSyncFinalizationResult, error) {
+	if err := finalization.validateUsageSyncFinalization(); err != nil {
+		return usageSyncFinalizationResult{}, err
+	}
+	if source.ProviderID != finalization.ProviderID {
+		return usageSyncFinalizationResult{}, errors.New("invalid Claude Code usage sync finalization")
+	}
+
+	discovered := make(map[UsageKey]struct{}, len(finalization.DiscoveredFileKeys))
+	for _, key := range finalization.DiscoveredFileKeys {
+		discovered[key] = struct{}{}
+	}
+	rows, err := store.executor().QueryContext(ctx, `
+		SELECT file_key FROM claude_code_usage_import_files WHERE source_id = ?
+	`, source.ID)
+	if err != nil {
+		return usageSyncFinalizationResult{}, err
+	}
+	var staleKeys []UsageKey
+	for rows.Next() {
+		var fileKey UsageKey
+		if err := rows.Scan(&fileKey); err != nil {
+			_ = rows.Close()
+			return usageSyncFinalizationResult{}, err
+		}
+		if _, ok := discovered[fileKey]; !ok {
+			staleKeys = append(staleKeys, fileKey)
+		}
+	}
+	if err := rows.Err(); err != nil {
+		_ = rows.Close()
+		return usageSyncFinalizationResult{}, err
+	}
+	if err := rows.Close(); err != nil {
+		return usageSyncFinalizationResult{}, err
+	}
+	for _, fileKey := range staleKeys {
+		if _, err := store.executor().ExecContext(ctx, `
+			DELETE FROM claude_code_usage_import_files WHERE source_id = ? AND file_key = ?
+		`, source.ID, fileKey); err != nil {
+			return usageSyncFinalizationResult{}, err
+		}
+	}
+	if err := store.deleteMissingUsageImportObservations(ctx, source.ID, discovered); err != nil {
+		return usageSyncFinalizationResult{}, err
+	}
+
+	var result usageSyncFinalizationResult
+	if err := store.executor().QueryRowContext(ctx, `
+		SELECT COUNT(1), COALESCE(SUM(invalid_lines), 0), COALESCE(SUM(unsupported_lines), 0)
+		FROM claude_code_usage_import_files
+		WHERE source_id = ?
+	`, source.ID).Scan(
+		&result.trackedUnits,
+		&result.invalidRecords,
+		&result.unsupportedRecords,
+	); err != nil {
+		return usageSyncFinalizationResult{}, err
+	}
+	return result, nil
+}
diff --git a/internal/store/usage_claude_code_diagnostics.go b/internal/store/usage_claude_code_diagnostics.go
new file mode 100644
index 0000000..6977abd
--- /dev/null
+++ b/internal/store/usage_claude_code_diagnostics.go
@@ -0,0 +1,92 @@
+package store
+
+import (
+	"encoding/json"
+	"errors"
+	"io"
+	"strings"
+)
+
+const (
+	ClaudeCodeInvalidJSON       = "malformed_json"
+	ClaudeCodeRecordTooLarge    = "record_too_large"
+	ClaudeCodeInvalidFields     = "invalid_fields"
+	ClaudeCodeInvalidTokens     = "invalid_tokens"
+	ClaudeCodeCacheMismatch     = "cache_tokens_mismatch"
+	ClaudeCodeIterationMismatch = "iteration_tokens_mismatch"
+	ClaudeCodeInvalidIdentity   = "invalid_identity"
+	ClaudeCodeInvalidTimestamp  = "invalid_timestamp"
+	ClaudeCodeTokenOverflow     = "token_overflow"
+)
+
+func DecodeClaudeCodeUsageInvalidReasons(state string, invalidLines int64) (map[string]int64, error) {
+	if len(state) > 4096 || !strings.HasPrefix(strings.TrimSpace(state), "{") || invalidLines < 0 {
+		return nil, errors.New("invalid Claude Code usage diagnostics")
+	}
+	decoder := json.NewDecoder(strings.NewReader(state))
+	decoder.UseNumber()
+	if token, err := decoder.Token(); err != nil || token != json.Delim('{') {
+		return nil, errors.New("invalid Claude Code usage diagnostics")
+	}
+	counts := make(map[string]int64)
+	var total int64
+	for decoder.More() {
+		key, err := decoder.Token()
+		if err != nil {
+			return nil, errors.New("invalid Claude Code usage diagnostics")
+		}
+		reason, ok := key.(string)
+		if !ok {
+			return nil, errors.New("invalid Claude Code usage diagnostics")
+		}
+		if _, duplicate := counts[reason]; duplicate {
+			return nil, errors.New("invalid Claude Code usage diagnostics")
+		}
+		switch reason {
+		case ClaudeCodeInvalidJSON, ClaudeCodeRecordTooLarge, ClaudeCodeInvalidFields,
+			ClaudeCodeInvalidTokens, ClaudeCodeCacheMismatch, ClaudeCodeIterationMismatch,
+			ClaudeCodeInvalidIdentity, ClaudeCodeInvalidTimestamp, ClaudeCodeTokenOverflow:
+		default:
+			return nil, errors.New("invalid Claude Code usage diagnostics")
+		}
+		value, err := decoder.Token()
+		if err != nil {
+			return nil, errors.New("invalid Claude Code usage diagnostics")
+		}
+		number, ok := value.(json.Number)
+		if !ok {
+			return nil, errors.New("invalid Claude Code usage diagnostics")
+		}
+		count, err := number.Int64()
+		if err != nil {
+			return nil, errors.New("invalid Claude Code usage diagnostics")
+		}
+		if count < 0 || count > invalidLines-total {
+			return nil, errors.New("invalid Claude Code usage diagnostics")
+		}
+		total += count
+		counts[reason] = count
+	}
+	if token, err := decoder.Token(); err != nil || token != json.Delim('}') {
+		return nil, errors.New("invalid Claude Code usage diagnostics")
+	}
+	if _, err := decoder.Token(); !errors.Is(err, io.EOF) {
+		return nil, errors.New("invalid Claude Code usage diagnostics")
+	}
+	return counts, nil
+}
+
+const claudeCodeUsageDiagnosticsViolationQuery = `SELECT COUNT(1)
+	FROM claude_code_usage_import_files AS f
+	WHERE CASE WHEN NOT json_valid(f.parser_state_json) THEN 1
+	ELSE json_type(f.parser_state_json) <> 'object'
+		OR length(CAST(f.parser_state_json AS BLOB)) > 4096
+		OR EXISTS (SELECT 1 FROM json_each(f.parser_state_json) AS reason
+			WHERE reason.key NOT IN ('malformed_json','record_too_large','invalid_fields',
+				'invalid_tokens','cache_tokens_mismatch','iteration_tokens_mismatch',
+				'invalid_identity','invalid_timestamp','token_overflow')
+				OR reason.type <> 'integer' OR reason.value < 0
+				OR reason.value > f.invalid_lines)
+		OR EXISTS (SELECT 1 FROM json_each(f.parser_state_json) GROUP BY key HAVING COUNT(1)>1)
+		OR (SELECT COALESCE(SUM(value),0) FROM json_each(f.parser_state_json)) > f.invalid_lines
+	END`
diff --git a/internal/store/usage_claude_code_facts.go b/internal/store/usage_claude_code_facts.go
new file mode 100644
index 0000000..160289e
--- /dev/null
+++ b/internal/store/usage_claude_code_facts.go
@@ -0,0 +1,254 @@
+package store
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"errors"
+	"reflect"
+)
+
+type ClaudeCodeUsagePricer func(CreateUsageFactParams) (*int64, UsageCostStatus, *int64, *UsagePriceSnapshot)
+
+func (s *Store) reconcileClaudeCodeUsageFacts(ctx context.Context, candidates []CreateUsageFactParams, price ClaudeCodeUsagePricer) (UsageInsertResult, error) {
+	var result UsageInsertResult
+	for _, candidate := range candidates {
+		if err := validateClaudeCodeUsageFact(candidate); err != nil {
+			return UsageInsertResult{}, err
+		}
+		existing, err := s.getClaudeCodeUsageFact(ctx, candidate.EventKey)
+		fresh := errors.Is(err, ErrNotFound)
+		if err != nil && !fresh {
+			return UsageInsertResult{}, err
+		}
+		merged := candidate
+		if !fresh {
+			if existing.SourceID != candidate.SourceID {
+				return UsageInsertResult{}, ErrUsageFactConflict
+			}
+			merged = mergeClaudeCodeUsageFact(existing, candidate)
+		}
+		if merged.TokenStatus >= UsageTokensPartialConflict {
+			merged.ModelKey = UsageUnknownModelKey
+			merged.InputTokens = 0
+			merged.CachedInputTokens = 0
+			merged.OutputTokens = 0
+			merged.TotalTokens = 0
+			merged.CacheWriteInputTokens = nil
+			merged.CacheCreationInputTokens = nil
+			merged.CacheWrite5mTokens = nil
+			merged.CacheWrite1hTokens = nil
+			merged.EstimatedCostMicros = nil
+			merged.CostStatus = UsageCostStatusUnknown
+			if merged.TokenStatus == UsageTokensFinalConflict {
+				merged.PriceSnapshot = nil
+				merged.PricingCatalogVersion = nil
+			}
+			merged.PricingEligible = false
+		} else if price != nil {
+			merged.EstimatedCostMicros, merged.CostStatus, merged.PricingCatalogVersion, merged.PriceSnapshot = price(merged)
+		}
+		if err := validateClaudeCodeUsageFact(merged); err != nil {
+			return UsageInsertResult{}, err
+		}
+		if !fresh && reflect.DeepEqual(existing, merged) {
+			result.Duplicates++
+			continue
+		}
+		if fresh {
+			if _, err := s.insertUsageFactsWithSessionPolicy(ctx, []CreateUsageFactParams{merged}, usageFactSessionStrict); err != nil {
+				return UsageInsertResult{}, err
+			}
+			result.Inserted++
+		} else {
+			result.Updated++
+		}
+		if err := s.writeClaudeCodeUsageFact(ctx, merged); err != nil {
+			return UsageInsertResult{}, err
+		}
+	}
+	return result, nil
+}
+
+func mergeClaudeCodeUsageFact(previous, candidate CreateUsageFactParams) CreateUsageFactParams {
+	merged := previous
+	switch {
+	case previous.TokenStatus == UsageTokensFinalConflict:
+	case previous.TokenStatus == UsageTokensComplete && candidate.TokenStatus == UsageTokensComplete:
+		if !sameClaudeCodeUsageTokens(previous, candidate, true) {
+			merged.TokenStatus = UsageTokensFinalConflict
+		} else {
+			mergeClaudeCodeCacheDetails(&merged, candidate)
+			merged.PricingEligible = previous.PricingEligible && candidate.PricingEligible
+		}
+	case previous.TokenStatus != UsageTokensComplete && candidate.TokenStatus == UsageTokensComplete:
+		merged = candidate
+		if previous.PriceSnapshot != nil && previous.PriceSnapshot.ModelKey == candidate.ModelKey {
+			merged.PriceSnapshot = previous.PriceSnapshot
+		}
+	case previous.TokenStatus == UsageTokensPartial && candidate.TokenStatus == UsageTokensPartial:
+		if !sameClaudeCodeUsageTokens(previous, candidate, false) {
+			merged.TokenStatus = UsageTokensPartialConflict
+		} else {
+			mergeClaudeCodeCacheDetails(&merged, candidate)
+			merged.PricingEligible = previous.PricingEligible && candidate.PricingEligible
+		}
+	}
+	if canonicalUsageObservationBefore(candidate.OccurredAtUnixMS, candidate.SessionKey, previous.OccurredAtUnixMS, previous.SessionKey) {
+		merged.SessionKey = candidate.SessionKey
+		merged.OccurredAtUnixMS = candidate.OccurredAtUnixMS
+	} else {
+		merged.SessionKey = previous.SessionKey
+		merged.OccurredAtUnixMS = previous.OccurredAtUnixMS
+	}
+	if previous.ModelKey == merged.ModelKey && previous.PriceSnapshot != nil {
+		merged.PriceSnapshot = previous.PriceSnapshot
+	}
+	return merged
+}
+
+func sameClaudeCodeUsageTokens(a, b CreateUsageFactParams, final bool) bool {
+	return a.ModelKey == b.ModelKey && a.InputTokens == b.InputTokens && a.CachedInputTokens == b.CachedInputTokens &&
+		(!final || a.OutputTokens == b.OutputTokens) && equalOptionalClaudeToken(a.CacheCreationInputTokens, b.CacheCreationInputTokens) &&
+		equalOptionalClaudeToken(a.CacheWrite5mTokens, b.CacheWrite5mTokens) && equalOptionalClaudeToken(a.CacheWrite1hTokens, b.CacheWrite1hTokens)
+}
+
+func equalOptionalClaudeToken(a, b *int64) bool { return a == nil || b == nil || *a == *b }
+
+func mergeClaudeCodeCacheDetails(target *CreateUsageFactParams, candidate CreateUsageFactParams) {
+	if target.CacheWrite5mTokens == nil {
+		target.CacheWrite5mTokens = candidate.CacheWrite5mTokens
+		target.CacheWrite1hTokens = candidate.CacheWrite1hTokens
+	}
+}
+
+func validateClaudeCodeUsageFact(fact CreateUsageFactParams) error {
+	if err := validateUsageFact(fact); err != nil {
+		return err
+	}
+	if !validClaudeCodeDerivedSessionKey(fact.SessionKey) || NormalizeUsageModelKey(fact.ModelKey) != fact.ModelKey || fact.TokenStatus < UsageTokensComplete || fact.TokenStatus > UsageTokensFinalConflict {
+		return errors.New("claude code usage fact is invalid")
+	}
+	if fact.OutputTokens > 0 && fact.TokenStatus == UsageTokensPartial || fact.TotalTokens-fact.OutputTokens != fact.InputTokens {
+		return errors.New("claude code usage totals are invalid")
+	}
+	if fact.CacheCreationInputTokens != nil && *fact.CacheCreationInputTokens > fact.InputTokens-fact.CachedInputTokens {
+		return errors.New("claude code cache totals are invalid")
+	}
+	if (fact.CacheWrite5mTokens == nil) != (fact.CacheWrite1hTokens == nil) {
+		return errors.New("claude code cache durations are invalid")
+	}
+	if fact.CacheWrite5mTokens != nil {
+		if fact.CacheCreationInputTokens == nil || *fact.CacheWrite5mTokens < 0 || *fact.CacheWrite1hTokens < 0 || *fact.CacheWrite5mTokens > *fact.CacheCreationInputTokens || *fact.CacheWrite1hTokens != *fact.CacheCreationInputTokens-*fact.CacheWrite5mTokens {
+			return errors.New("claude code cache durations are invalid")
+		}
+	}
+	if fact.PriceSnapshot != nil {
+		rates := fact.PriceSnapshot
+		if NormalizeUsageModelKey(rates.ModelKey) == UsageUnknownModelKey || fact.TokenStatus < UsageTokensPartialConflict && rates.ModelKey != fact.ModelKey || rates.Version <= 0 || rates.Input <= 0 || rates.Input > 1_000_000_000 || rates.Output <= 0 || rates.Output > 1_000_000_000 {
+			return errors.New("claude code pricing snapshot is invalid")
+		}
+		for _, rate := range []*int64{rates.CachedInput, rates.CacheWrite5m, rates.CacheWrite1h} {
+			if rate != nil && (*rate <= 0 || *rate > 1_000_000_000) {
+				return errors.New("claude code pricing snapshot is invalid")
+			}
+		}
+	}
+	_, _, err := usageCostStorageValues(fact.CostStatus, fact.EstimatedCostMicros)
+	return err
+}
+
+func (s *Store) getClaudeCodeUsageFact(ctx context.Context, key UsageKey) (CreateUsageFactParams, error) {
+	fact := CreateUsageFactParams{EventKey: key}
+	var snapshot string
+	err := s.executor().QueryRowContext(ctx, `SELECT f.source_id, COALESCE(s.session_key,''), m.model_key, f.occurred_at_unix_ms,
+ f.input_tokens, f.cached_input_tokens, f.output_tokens, f.total_tokens, f.estimated_cost_micros, f.cost_status,
+ f.pricing_catalog_version, f.cache_write_input_tokens, f.cache_creation_input_tokens, f.token_status,
+ f.cache_write_5m_tokens, f.cache_write_1h_tokens, f.pricing_eligible, f.price_snapshot_json
+ FROM usage_facts f JOIN usage_models m ON m.id=f.model_id AND m.source_id=f.source_id
+ LEFT JOIN usage_sessions s ON s.id=f.session_id AND s.source_id=f.source_id WHERE f.event_key=?`, key).Scan(
+		&fact.SourceID, &fact.SessionKey, &fact.ModelKey, &fact.OccurredAtUnixMS, &fact.InputTokens, &fact.CachedInputTokens, &fact.OutputTokens, &fact.TotalTokens,
+		&fact.EstimatedCostMicros, &fact.CostStatus, &fact.PricingCatalogVersion, &fact.CacheWriteInputTokens, &fact.CacheCreationInputTokens, &fact.TokenStatus,
+		&fact.CacheWrite5mTokens, &fact.CacheWrite1hTokens, &fact.PricingEligible, &snapshot)
+	if errors.Is(err, sql.ErrNoRows) {
+		return fact, ErrNotFound
+	}
+	if err != nil {
+		return fact, err
+	}
+	if snapshot != "{}" {
+		if err := json.Unmarshal([]byte(snapshot), &fact.PriceSnapshot); err != nil {
+			return fact, errors.New("claude code pricing snapshot is invalid")
+		}
+	}
+	return fact, nil
+}
+
+func (s *Store) writeClaudeCodeUsageFact(ctx context.Context, fact CreateUsageFactParams) error {
+	sessionID, err := s.resolveUsageSessionID(ctx, fact.SourceID, fact.SessionKey, make(map[string]int64))
+	if err != nil {
+		return err
+	}
+	modelID, err := s.resolveUsageModelID(ctx, fact.SourceID, fact.ModelKey, make(map[string]int64))
+	if err != nil {
+		return err
+	}
+	snapshot := "{}"
+	if fact.PriceSnapshot != nil {
+		encoded, err := json.Marshal(fact.PriceSnapshot)
+		if err != nil {
+			return err
+		}
+		snapshot = string(encoded)
+	}
+	_, err = s.executor().ExecContext(ctx, `UPDATE usage_facts SET session_id=?, model_id=?, occurred_at_unix_ms=?,
+ input_tokens=?, cached_input_tokens=?, output_tokens=?, total_tokens=?, estimated_cost_micros=?, cost_status=?,
+ pricing_catalog_version=?, cache_write_input_tokens=?, cache_creation_input_tokens=?, token_status=?,
+ cache_write_5m_tokens=?, cache_write_1h_tokens=?, pricing_eligible=?, price_snapshot_json=? WHERE source_id=? AND event_key=?`,
+		sessionID, modelID, fact.OccurredAtUnixMS, fact.InputTokens, fact.CachedInputTokens, fact.OutputTokens, fact.TotalTokens, fact.EstimatedCostMicros, fact.CostStatus,
+		fact.PricingCatalogVersion, fact.CacheWriteInputTokens, fact.CacheCreationInputTokens, fact.TokenStatus, fact.CacheWrite5mTokens, fact.CacheWrite1hTokens, fact.PricingEligible, snapshot, fact.SourceID, fact.EventKey)
+	return err
+}
+
+func (s *Store) BackfillClaudeCodeUsageCosts(ctx context.Context, sourceID, generation int64, price ClaudeCodeUsagePricer) error {
+	return s.WithTransaction(ctx, func(tx *Store) error {
+		source, err := tx.reserveCurrentUsageSyncForWrite(ctx, sourceID, generation)
+		if err != nil {
+			return err
+		}
+		if source.ProviderID != "claude-code" {
+			return errors.New("claude code usage source is invalid")
+		}
+		rows, err := tx.executor().QueryContext(ctx, `SELECT event_key FROM usage_facts WHERE source_id=? AND cost_status=0 AND token_status IN (0,1) AND pricing_eligible=1`, sourceID)
+		if err != nil {
+			return err
+		}
+		var keys []UsageKey
+		for rows.Next() {
+			var key UsageKey
+			if err := rows.Scan(&key); err != nil {
+				_ = rows.Close()
+				return err
+			}
+			keys = append(keys, key)
+		}
+		err = rows.Err()
+		closeErr := rows.Close()
+		if err != nil {
+			return err
+		}
+		if closeErr != nil {
+			return closeErr
+		}
+		for _, key := range keys {
+			fact, err := tx.getClaudeCodeUsageFact(ctx, key)
+			if err != nil {
+				return err
+			}
+			if _, err := tx.reconcileClaudeCodeUsageFacts(ctx, []CreateUsageFactParams{fact}, price); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+}
diff --git a/internal/store/usage_claude_code_test.go b/internal/store/usage_claude_code_test.go
new file mode 100644
index 0000000..d108c19
--- /dev/null
+++ b/internal/store/usage_claude_code_test.go
@@ -0,0 +1,144 @@
+package store
+
+import (
+	"context"
+	"errors"
+	"testing"
+)
+
+func TestClaudeCodeUsageMigrationIntegrity(t *testing.T) {
+	ctx := context.Background()
+	db := migratedTestStore(t, ctx)
+	defer closeTestStore(t, db)
+	report, err := db.InspectIntegrity(ctx, IntegrityCurrentBaseline)
+	if err != nil || len(report.Issues) != 0 {
+		t.Fatalf("integrity: %+v, %v", report, err)
+	}
+}
+
+func TestClaudeCodeUsageReconciliationAcrossFilesAndConflictOrders(t *testing.T) {
+	for _, order := range [][]int{{0, 1, 2}, {2, 0, 1}, {1, 2, 0}} {
+		ctx := context.Background()
+		db := migratedTestStore(t, ctx)
+		createUsageProviderFixture(t, ctx, db, "claude-code")
+		source, err := db.BeginUsageSync(ctx, "claude-code", "claude-code-session-jsonl", 1)
+		if err != nil {
+			t.Fatal(err)
+		}
+		write := int64(10)
+		partial := CreateUsageFactParams{EventKey: testUsageKey("shared-request"), SourceID: source.ID, SessionKey: "derived-" + testUsageKey("session-a").String(), ModelKey: "claude-opus-5-5", InputTokens: 100, CachedInputTokens: 20, TotalTokens: 100, CacheCreationInputTokens: &write, CacheWriteInputTokens: &write, TokenStatus: UsageTokensPartial}
+		final := partial
+		final.TokenStatus = UsageTokensComplete
+		final.OutputTokens = 30
+		final.TotalTokens = 130
+		conflicting := final
+		conflicting.OutputTokens = 40
+		conflicting.TotalTokens = 140
+		candidates := []CreateUsageFactParams{partial, final, conflicting}
+		for i, index := range order {
+			fact := candidates[index]
+			params := claudeCodeTestImport(source, fact, testUsageKey(string(rune('a'+i))))
+			if _, err := db.CommitClaudeCodeUsageImport(ctx, params); err != nil {
+				t.Fatal(err)
+			}
+		}
+		summary, err := db.UsageSummary(ctx, "claude-code")
+		if err != nil || summary.EventCount != 1 || summary.TotalTokens != 0 || summary.ConflictingEventCount != 1 {
+			t.Fatalf("order %v: %+v, %v", order, summary, err)
+		}
+		if _, err := db.CommitClaudeCodeUsageImport(ctx, claudeCodeTestImport(source, final, testUsageKey("retry"))); err != nil {
+			t.Fatal(err)
+		}
+		summary, err = db.UsageSummary(ctx, "claude-code")
+		if err != nil || summary.ConflictingEventCount != 1 || summary.TotalTokens != 0 {
+			t.Fatalf("conflict disappeared: %+v, %v", summary, err)
+		}
+		closeTestStore(t, db)
+	}
+}
+
+func TestClaudeCodePartialConflictCanCompleteAndStaleCursorRollsBackUpgrade(t *testing.T) {
+	ctx := context.Background()
+	db := migratedTestStore(t, ctx)
+	defer closeTestStore(t, db)
+	createUsageProviderFixture(t, ctx, db, "claude-code")
+	source, err := db.BeginUsageSync(ctx, "claude-code", "claude-code-session-jsonl", 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	write := int64(0)
+	partial := CreateUsageFactParams{EventKey: testUsageKey("partial"), SourceID: source.ID, SessionKey: "derived-" + testUsageKey("session").String(), ModelKey: "claude-opus-5-5", InputTokens: 100, TotalTokens: 100, TokenStatus: UsageTokensPartial, CacheCreationInputTokens: &write, CacheWriteInputTokens: &write}
+	first := claudeCodeTestImport(source, partial, testUsageKey("first"))
+	if _, err := db.CommitClaudeCodeUsageImport(ctx, first); err != nil {
+		t.Fatal(err)
+	}
+	cursor, err := db.GetClaudeCodeUsageImportFile(ctx, source.ID, first.File.FileKey)
+	if err != nil {
+		t.Fatal(err)
+	}
+	conflicting := partial
+	conflicting.InputTokens = 120
+	conflicting.TotalTokens = 120
+	if _, err := db.CommitClaudeCodeUsageImport(ctx, claudeCodeTestImport(source, conflicting, testUsageKey("second"))); err != nil {
+		t.Fatal(err)
+	}
+	final := partial
+	final.TokenStatus = UsageTokensComplete
+	final.OutputTokens = 30
+	final.TotalTokens = 130
+	stale := claudeCodeTestImport(source, final, first.File.FileKey)
+	stale.Expected = &cursor
+	stale.Expected.UpdatedAtUnixMS--
+	stale.File.ImportedFacts = 2
+	if _, err := db.CommitClaudeCodeUsageImport(ctx, stale); !errors.Is(err, ErrUsageCursorConflict) {
+		t.Fatalf("stale cursor: %v", err)
+	}
+	summary, err := db.UsageSummary(ctx, "claude-code")
+	if err != nil || summary.ConflictingEventCount != 1 || summary.TotalTokens != 0 {
+		t.Fatalf("failed CAS committed upgrade: %+v, %v", summary, err)
+	}
+	if _, err := db.CommitClaudeCodeUsageImport(ctx, claudeCodeTestImport(source, final, testUsageKey("third"))); err != nil {
+		t.Fatal(err)
+	}
+	summary, err = db.UsageSummary(ctx, "claude-code")
+	if err != nil || summary.TotalTokens != 130 || summary.ConflictingEventCount != 0 || summary.IncompleteEventCount != 0 {
+		t.Fatalf("final did not resolve partial conflict: %+v, %v", summary, err)
+	}
+}
+
+func claudeCodeTestImport(source UsageSource, fact CreateUsageFactParams, key UsageKey) CommitClaudeCodeUsageImportParams {
+	return CommitClaudeCodeUsageImportParams{ProviderID: "claude-code", Generation: source.SyncGeneration, Facts: []CreateUsageFactParams{fact}, File: ClaudeCodeUsageImportFile{SourceID: source.ID, FileKey: key, ImportedFacts: 1, ParserRevision: 1, IdentityRevision: 1, EventDigest: testUsageKey("events"), CheckpointRevision: 1, MetadataDigest: testUsageKey("metadata"), BoundaryDigest: testUsageKey("boundary"), CheckpointEventDigest: testUsageKey("observations"), ParserStateJSON: "{}"}}
+}
+
+func TestClaudeCodeUsageDiagnosticsRejectUnrecognizedDataAndInvalidCounts(t *testing.T) {
+	ctx := context.Background()
+	db := migratedTestStore(t, ctx)
+	defer closeTestStore(t, db)
+	createUsageProviderFixture(t, ctx, db, "claude-code")
+	source, err := db.BeginUsageSync(ctx, "claude-code", "claude-code-session-jsonl", 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	params := claudeCodeTestImport(source, CreateUsageFactParams{}, testUsageKey("diagnostics"))
+	params.Facts = nil
+	params.File.ImportedFacts = 0
+	params.File.InvalidLines = 1
+	params.File.ParserStateJSON = `{"cache_tokens_mismatch":1}`
+	if _, err := db.CommitClaudeCodeUsageImport(ctx, params); err != nil {
+		t.Fatal(err)
+	}
+	for _, state := range []string{`{"prompt":1}`, `{"cache_tokens_mismatch":-1}`, `{"cache_tokens_mismatch":2}`, `{"cache_tokens_mismatch":"1"}`, `{"cache_tokens_mismatch":null}`, `{"cache_tokens_mismatch":-1,"cache_tokens_mismatch":1}`} {
+		params.File.FileKey = testUsageKey("rejected")
+		params.File.ParserStateJSON = state
+		if _, err := db.CommitClaudeCodeUsageImport(ctx, params); err == nil {
+			t.Fatal("invalid diagnostics accepted")
+		}
+		if _, err := db.executor().ExecContext(ctx, `UPDATE claude_code_usage_import_files SET parser_state_json=? WHERE source_id=?`, state, source.ID); err != nil {
+			t.Fatal(err)
+		}
+		report, err := db.InspectIntegrity(ctx, IntegrityCurrentBaseline)
+		if err != nil || len(report.Issues) == 0 {
+			t.Fatalf("invalid diagnostic integrity: %+v, %v", report, err)
+		}
+	}
+}
diff --git a/internal/store/usage_report.go b/internal/store/usage_report.go
index a6de343..3dedec8 100644
--- a/internal/store/usage_report.go
+++ b/internal/store/usage_report.go
@@ -9,6 +9,8 @@ import (
 )
 
 type UsageSummary struct {
+	IncompleteEventCount      int64
+	ConflictingEventCount     int64
 	ProviderID                string
 	Sources                   []string
 	EventCount                int64
@@ -39,6 +41,11 @@ type UsageTimeBucket struct {
 }
 
 type UsageAggregate struct {
+	MissingOutputCostEventCount   int64
+	MissingCacheTTLEventCount     int64
+	MissingCacheRateEventCount    int64
+	IncompleteEventCount          int64
+	ConflictingEventCount         int64
 	EventCount                    int64
 	SessionCount                  int64
 	FreshInputTokens              int64
@@ -70,6 +77,7 @@ type UsageModelAggregate struct {
 }
 
 type UsageImportSummary struct {
+	InvalidReasons     map[string]int64
 	TrackedFiles       int64
 	LastSyncedAtUnixMS int64
 	InvalidLines       int64
@@ -115,6 +123,8 @@ func (s *Store) usageSummary(ctx context.Context, providerID string) (UsageSumma
 	if err != nil {
 		return UsageSummary{}, err
 	}
+	summary.IncompleteEventCount = aggregate.IncompleteEventCount
+	summary.ConflictingEventCount = aggregate.ConflictingEventCount
 	summary.EventCount = aggregate.EventCount
 	summary.InputTokens = aggregate.InputTokens
 	summary.CachedInputTokens = aggregate.CachedInputTokens
@@ -405,7 +415,27 @@ func (s *Store) queryUsageSourceSummary(ctx context.Context, sourceIDs []int64)
 		&summary.InvalidLines,
 		&summary.UnsupportedLines,
 	)
-	return summary, err
+	if err != nil {
+		return summary, err
+	}
+	summary.InvalidReasons = make(map[string]int64)
+	where, args = usageSourceIDWhere("f", sourceIDs)
+	rows, err := s.executor().QueryContext(ctx, `SELECT reason.key, SUM(reason.value)
+		FROM claude_code_usage_import_files AS f, json_each(f.parser_state_json) AS reason
+		WHERE `+where+` GROUP BY reason.key`, args...)
+	if err != nil {
+		return summary, err
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var reason string
+		var count int64
+		if err := rows.Scan(&reason, &count); err != nil {
+			return summary, err
+		}
+		summary.InvalidReasons[reason] = count
+	}
+	return summary, rows.Err()
 }
 
 func usageSourceIDWhere(alias string, sourceIDs []int64) (string, []any) {
@@ -430,6 +460,15 @@ func usageIDWhere(column string, sourceIDs []int64) (string, []any) {
 func usageFactAggregateColumns(alias, undatedExpression string) string {
 	return fmt.Sprintf(`
 		COUNT(%[1]s.id),
+		COALESCE(SUM(CASE WHEN %[1]s.cost_status=%[3]d AND %[1]s.token_status=1 THEN 1 ELSE 0 END),0),
+		COALESCE(SUM(CASE WHEN %[1]s.cost_status=%[3]d AND %[1]s.cache_creation_input_tokens>0 AND %[1]s.cache_write_5m_tokens IS NULL AND %[1]s.price_snapshot_json<>'{}' THEN 1 ELSE 0 END),0),
+		COALESCE(SUM(CASE WHEN %[1]s.cost_status=%[3]d AND %[1]s.price_snapshot_json<>'{}' AND (
+			(%[1]s.cached_input_tokens>0 AND json_extract(%[1]s.price_snapshot_json,'$.cached_input') IS NULL)
+			OR (%[1]s.cache_write_5m_tokens>0 AND json_extract(%[1]s.price_snapshot_json,'$.cache_write_5m') IS NULL)
+			OR (%[1]s.cache_write_1h_tokens>0 AND json_extract(%[1]s.price_snapshot_json,'$.cache_write_1h') IS NULL)
+		) THEN 1 ELSE 0 END),0),
+ COALESCE(SUM(CASE WHEN %[1]s.token_status=1 THEN 1 ELSE 0 END),0),
+ COALESCE(SUM(CASE WHEN %[1]s.token_status IN (2,3) THEN 1 ELSE 0 END),0),
 		COUNT(DISTINCT %[1]s.session_id),
 		COALESCE(SUM(%[1]s.input_tokens - %[1]s.cached_input_tokens), 0),
 		COALESCE(SUM(%[1]s.input_tokens), 0),
@@ -467,6 +506,11 @@ func scanUsageAggregate(row rowScanner) (UsageAggregate, error) {
 func usageAggregateScanTargets(aggregate *UsageAggregate) []any {
 	return []any{
 		&aggregate.EventCount,
+		&aggregate.MissingOutputCostEventCount,
+		&aggregate.MissingCacheTTLEventCount,
+		&aggregate.MissingCacheRateEventCount,
+		&aggregate.IncompleteEventCount,
+		&aggregate.ConflictingEventCount,
 		&aggregate.SessionCount,
 		&aggregate.FreshInputTokens,
 		&aggregate.InputTokens,
diff --git a/internal/store/usage_report_test.go b/internal/store/usage_report_test.go
index 7adc7df..7156077 100644
--- a/internal/store/usage_report_test.go
+++ b/internal/store/usage_report_test.go
@@ -194,6 +194,42 @@ func TestUsageSummaryPreservesPersistedCostStatusMeanings(t *testing.T) {
 	}
 }
 
+func TestUsageReportDoesNotInferMissingCacheRatesFromLegacyPartialEstimates(t *testing.T) {
+	for _, providerID := range []string{"codex", "grok-build"} {
+		t.Run(providerID, func(t *testing.T) {
+			ctx := context.Background()
+			db := migratedTestStore(t, ctx)
+			defer closeTestStore(t, db)
+			createUsageProviderFixture(t, ctx, db, providerID)
+			source, err := db.BeginUsageSync(ctx, providerID, providerID+"-session-jsonl", 1)
+			if err != nil {
+				t.Fatal(err)
+			}
+			cost := int64(10)
+			facts := []CreateUsageFactParams{
+				{EventKey: testUsageKey("no-cache"), SourceID: source.ID, ModelKey: "model", OccurredAtUnixMS: 1000, InputTokens: 100, OutputTokens: 30, TotalTokens: 130, EstimatedCostMicros: &cost, CostStatus: UsageCostStatusPartial},
+				{EventKey: testUsageKey("cached"), SourceID: source.ID, ModelKey: "model", OccurredAtUnixMS: 1500, InputTokens: 100, CachedInputTokens: 20, OutputTokens: 30, TotalTokens: 130, EstimatedCostMicros: &cost, CostStatus: UsageCostStatusPartial},
+			}
+			if _, err := db.InsertUsageFacts(ctx, testUsageFactBatch(source, facts)); err != nil {
+				t.Fatal(err)
+			}
+			report, err := db.UsageReport(ctx, UsageReportQuery{ProviderID: providerID, EndUnixMS: 3000, Buckets: []UsageTimeBucket{{StartUnixMS: 0, EndUnixMS: 3000}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			aggregates := []UsageAggregate{report.Summary, report.Models[0].UsageAggregate, report.Trend[0].UsageAggregate}
+			for _, aggregate := range aggregates {
+				if aggregate.PartialCostEventCount != 2 || aggregate.EstimatedCostMicros != 20 {
+					t.Fatalf("partial estimate changed: %+v", aggregate)
+				}
+				if aggregate.MissingCacheRateEventCount != 0 || aggregate.MissingCacheTTLEventCount != 0 || aggregate.MissingOutputCostEventCount != 0 {
+					t.Fatalf("legacy estimate received a Claude-specific cause: %+v", aggregate)
+				}
+			}
+		})
+	}
+}
+
 func TestUsageSummaryKeepsSourcesAndFactsInOneSnapshot(t *testing.T) {
 	registerUsageSummarySnapshotBarrier(t)
 	ctx := context.Background()
diff --git a/internal/usage/claude_code.go b/internal/usage/claude_code.go
new file mode 100644
index 0000000..8d453ec
--- /dev/null
+++ b/internal/usage/claude_code.go
@@ -0,0 +1,293 @@
+package usage
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"io/fs"
+	"math"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	claudeconfig "github.com/strahe/profiledeck/internal/claudecode/config"
+	"github.com/strahe/profiledeck/internal/store"
+)
+
+const (
+	SourceClaudeCodeSessionJSONL    = "claude-code-session-jsonl"
+	ClaudeCodeUsageParserRevision   = int64(3)
+	ClaudeCodeUsageIdentityRevision = int64(1)
+	maxClaudeCodeSessionLineBytes   = 16 * 1024 * 1024
+)
+
+func ListClaudeCodeSessionFilesContext(ctx context.Context, dir string) ([]SourceFile, error) {
+	files, err := listClaudeCodeSessionFiles(ctx, dir)
+	if err != nil {
+		if ctx.Err() != nil {
+			return nil, ctx.Err()
+		}
+		return nil, errors.New("claude code session files could not be read")
+	}
+	return files, nil
+}
+
+func listClaudeCodeSessionFiles(ctx context.Context, dir string) ([]SourceFile, error) {
+	root, err := claudeconfig.ResolveConfigDir(dir)
+	if err != nil {
+		return nil, err
+	}
+	info, err := os.Lstat(root)
+	if errors.Is(err, os.ErrNotExist) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	if info.Mode()&os.ModeSymlink != 0 || !info.IsDir() {
+		return nil, errors.New("claude code log directory is unavailable")
+	}
+	projects := filepath.Join(root, "projects")
+	info, err = os.Lstat(projects)
+	if errors.Is(err, os.ErrNotExist) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	if info.Mode()&os.ModeSymlink != 0 || !info.IsDir() {
+		return nil, errors.New("claude code projects directory is unavailable")
+	}
+	var files []SourceFile
+	err = filepath.WalkDir(projects, func(path string, entry fs.DirEntry, walkErr error) error {
+		if err := ctx.Err(); err != nil {
+			return err
+		}
+		if walkErr != nil {
+			return walkErr
+		}
+		if entry.Type()&os.ModeSymlink != 0 {
+			return nil
+		}
+		relative, err := filepath.Rel(projects, path)
+		if err != nil {
+			return err
+		}
+		parts := strings.Split(relative, string(filepath.Separator))
+		if entry.IsDir() {
+			if len(parts) > 3 || len(parts) == 3 && parts[2] != "subagents" {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+		main := len(parts) == 2 && strings.HasSuffix(parts[1], ".jsonl")
+		child := len(parts) == 4 && parts[2] == "subagents" && strings.HasPrefix(parts[3], "agent-") && strings.HasSuffix(parts[3], ".jsonl")
+		if !main && !child {
+			return nil
+		}
+		info, err := entry.Info()
+		if err != nil {
+			return err
+		}
+		if !info.Mode().IsRegular() {
+			return nil
+		}
+		key, err := SourceKey(path)
+		if err != nil {
+			return err
+		}
+		files = append(files, sourceFileFromInfo(path, key, info))
+		return nil
+	})
+	return files, err
+}
+
+type claudeCacheCreation struct {
+	FiveMinutes *int64 `json:"ephemeral_5m_input_tokens"`
+	OneHour     *int64 `json:"ephemeral_1h_input_tokens"`
+}
+
+type claudeUsage struct {
+	Input      *int64               `json:"input_tokens"`
+	Output     *int64               `json:"output_tokens"`
+	Read       *int64               `json:"cache_read_input_tokens"`
+	Write      *int64               `json:"cache_creation_input_tokens"`
+	Creation   *claudeCacheCreation `json:"cache_creation"`
+	Iterations []claudeIteration    `json:"iterations"`
+	Speed      string               `json:"speed"`
+	Geo        string               `json:"inference_geo"`
+	ServerTool map[string]int64     `json:"server_tool_use"`
+}
+
+type claudeIteration struct {
+	claudeUsage
+	Type  string `json:"type"`
+	Model string `json:"model"`
+}
+
+func parseClaudeCodeSessionLine(line []byte) (*Event, bool, bool, error) {
+	event, reason, unsupported, err := parseClaudeCodeSessionObservation(line)
+	return event, reason != "", unsupported, err
+}
+
+func parseClaudeCodeSessionObservation(line []byte) (*Event, string, bool, error) {
+	return parseClaudeCodeSessionObservationForRevision(line, ClaudeCodeUsageParserRevision)
+}
+
+func parseClaudeCodeSessionObservationForRevision(line []byte, revision int64) (*Event, string, bool, error) {
+	var record struct {
+		Type      string `json:"type"`
+		RequestID string `json:"requestId"`
+		SessionID string `json:"sessionId"`
+		Timestamp string `json:"timestamp"`
+		Message   struct {
+			ID         string          `json:"id"`
+			Model      string          `json:"model"`
+			StopReason *string         `json:"stop_reason"`
+			Usage      json.RawMessage `json:"usage"`
+		} `json:"message"`
+	}
+	if !json.Valid(line) {
+		return nil, store.ClaudeCodeInvalidJSON, false, errors.New("session record is invalid")
+	}
+	if err := json.Unmarshal(line, &record); err != nil {
+		return nil, store.ClaudeCodeInvalidFields, false, nil
+	}
+	if record.Type != "assistant" || record.Message.Model == "<synthetic>" {
+		return nil, "", false, nil
+	}
+	if len(record.Message.Usage) == 0 || string(record.Message.Usage) == "null" || record.RequestID == "" || record.Message.ID == "" || record.SessionID == "" {
+		return nil, "", true, nil
+	}
+	var fields map[string]json.RawMessage
+	if err := json.Unmarshal(record.Message.Usage, &fields); err != nil {
+		return nil, store.ClaudeCodeInvalidFields, false, nil
+	}
+	if iterations := fields["iterations"]; len(iterations) > 0 && string(iterations) != "null" && iterations[0] != '[' {
+		return nil, "", true, nil
+	}
+	usage := &claudeUsage{}
+	if err := json.Unmarshal(record.Message.Usage, usage); err != nil {
+		return nil, store.ClaudeCodeInvalidFields, false, nil
+	}
+	if len(record.RequestID) > 256 || len(record.Message.ID) > 256 || len(record.SessionID) > 256 {
+		return nil, store.ClaudeCodeInvalidIdentity, false, nil
+	}
+	model := store.NormalizeUsageModelKey(record.Message.Model)
+	if model == store.UsageUnknownModelKey {
+		return nil, "", true, nil
+	}
+	final := record.Message.StopReason != nil && *record.Message.StopReason != ""
+	if final {
+		switch *record.Message.StopReason {
+		case "end_turn", "tool_use", "max_tokens", "stop_sequence", "refusal", "pause_turn":
+		case "model_context_window_exceeded":
+			if revision < 3 {
+				return nil, "", true, nil
+			}
+		default:
+			return nil, "", true, nil
+		}
+	}
+	// Claude Code clears these counts when restoring history, leaving nested usage intact.
+	if revision >= 3 && final && usage.Input != nil && *usage.Input == 0 && usage.Read != nil && *usage.Read == 0 && usage.Write != nil && *usage.Write == 0 && usage.Output != nil && *usage.Output == 0 {
+		return nil, "", false, nil
+	}
+	if reason := invalidClaudeUsageReason(usage, final); reason != "" {
+		return nil, reason, false, nil
+	}
+	if len(usage.Iterations) > 0 {
+		if len(usage.Iterations) != 1 || usage.Iterations[0].Type != "message" || usage.Iterations[0].Model != "" && usage.Iterations[0].Model != model {
+			return nil, "", true, nil
+		}
+		iteration := &usage.Iterations[0].claudeUsage
+		if invalidClaudeUsageReason(iteration, final) != "" || *iteration.Input != *usage.Input || *iteration.Read != *usage.Read || *iteration.Write != *usage.Write || final && *iteration.Output != *usage.Output {
+			return nil, store.ClaudeCodeIterationMismatch, false, nil
+		}
+		if usage.Creation != nil && iteration.Creation != nil && (*usage.Creation.FiveMinutes != *iteration.Creation.FiveMinutes || *usage.Creation.OneHour != *iteration.Creation.OneHour) {
+			return nil, store.ClaudeCodeIterationMismatch, false, nil
+		}
+		if usage.Creation == nil {
+			usage.Creation = iteration.Creation
+		}
+	}
+	occurred, err := time.Parse(time.RFC3339Nano, record.Timestamp)
+	if err != nil || occurred.UnixMilli() <= 0 {
+		return nil, store.ClaudeCodeInvalidTimestamp, false, nil
+	}
+	input, ok := addClaudeTokens(*usage.Input, *usage.Read, *usage.Write)
+	if !ok {
+		return nil, store.ClaudeCodeTokenOverflow, false, nil
+	}
+	event := Event{EventKey: claudeCodeIdentity("request", record.RequestID, record.Message.ID), SessionID: "derived-" + claudeCodeIdentity("session", record.SessionID).String(), Model: model, OccurredAtUnixMS: occurred.UnixMilli(), InputTokens: input, CachedInputTokens: *usage.Read, CacheWriteInputTokens: usage.Write, CacheCreationInputTokens: usage.Write, TokenStatus: store.UsageTokensPartial, PricingEligible: true}
+	if usage.Creation != nil {
+		event.CacheWrite5mTokens = usage.Creation.FiveMinutes
+		event.CacheWrite1hTokens = usage.Creation.OneHour
+	}
+	if final {
+		event.TokenStatus = store.UsageTokensComplete
+		event.OutputTokens = *usage.Output
+	}
+	event.TotalTokens, ok = addClaudeTokens(input, event.OutputTokens)
+	if !ok {
+		return nil, store.ClaudeCodeTokenOverflow, false, nil
+	}
+	if usage.Speed != "" && usage.Speed != "standard" || usage.Geo != "" && usage.Geo != "not_available" && usage.Geo != "global" {
+		event.PricingEligible = false
+	}
+	for _, count := range usage.ServerTool {
+		if count != 0 {
+			event.PricingEligible = false
+		}
+	}
+	return &event, "", false, nil
+}
+
+func invalidClaudeUsageReason(usage *claudeUsage, final bool) string {
+	if usage.Input == nil || usage.Read == nil || usage.Write == nil || final && usage.Output == nil {
+		return store.ClaudeCodeInvalidTokens
+	}
+	for _, value := range []*int64{usage.Input, usage.Read, usage.Write, usage.Output} {
+		if value != nil && *value < 0 {
+			return store.ClaudeCodeInvalidTokens
+		}
+	}
+	if usage.Creation != nil {
+		if usage.Creation.FiveMinutes == nil || usage.Creation.OneHour == nil {
+			return store.ClaudeCodeInvalidTokens
+		}
+		sum, ok := addClaudeTokens(*usage.Creation.FiveMinutes, *usage.Creation.OneHour)
+		if !ok || sum != *usage.Write {
+			return store.ClaudeCodeCacheMismatch
+		}
+	}
+	return ""
+}
+
+func addClaudeTokens(values ...int64) (int64, bool) {
+	var total int64
+	for _, value := range values {
+		if value < 0 || value > math.MaxInt64-total {
+			return 0, false
+		}
+		total += value
+	}
+	return total, true
+}
+
+func claudeCodeIdentity(kind string, values ...string) store.UsageKey {
+	hash := sha256.New()
+	_, _ = hash.Write([]byte("profiledeck-claude-code-" + kind + "-v1\x00" + claudeconfig.ProviderID + "\x00" + SourceClaudeCodeSessionJSONL))
+	for _, value := range values {
+		var size [8]byte
+		binary.BigEndian.PutUint64(size[:], uint64(len(value)))
+		_, _ = hash.Write(size[:])
+		_, _ = hash.Write([]byte(value))
+	}
+	var key store.UsageKey
+	copy(key[:], hash.Sum(nil))
+	return key
+}
diff --git a/internal/usage/claude_code_pricing.go b/internal/usage/claude_code_pricing.go
new file mode 100644
index 0000000..6313395
--- /dev/null
+++ b/internal/usage/claude_code_pricing.go
@@ -0,0 +1,73 @@
+package usage
+
+import (
+	"context"
+
+	"github.com/strahe/profiledeck/internal/pricing"
+	"github.com/strahe/profiledeck/internal/store"
+)
+
+func claudeCodePricer(catalog pricing.Catalog) store.ClaudeCodeUsagePricer {
+	return func(fact store.CreateUsageFactParams) (*int64, store.UsageCostStatus, *int64, *store.UsagePriceSnapshot) {
+		if !fact.PricingEligible || fact.TokenStatus >= store.UsageTokensPartialConflict {
+			return nil, CostStatusUnknown, nil, nil
+		}
+		snapshot := fact.PriceSnapshot
+		if snapshot == nil {
+			selected, ok := catalog.Select("claude-code", fact.ModelKey, fact.OccurredAtUnixMS)
+			if !ok {
+				return nil, CostStatusUnknown, nil, nil
+			}
+			snapshot = &store.UsagePriceSnapshot{ModelKey: fact.ModelKey, Version: selected.Version, Input: selected.Rates.Input, CachedInput: selected.Rates.CachedInput, CacheWrite5m: selected.Rates.CacheWrite, CacheWrite1h: selected.Rates.CacheWrite1h, Output: selected.Rates.Output}
+		}
+		if fact.CacheCreationInputTokens == nil {
+			return nil, CostStatusUnknown, nil, nil
+		}
+		fresh := fact.InputTokens - fact.CachedInputTokens - *fact.CacheCreationInputTokens
+		partial := fact.TokenStatus != store.UsageTokensComplete
+		cost := int64(0)
+		components := []struct {
+			count int64
+			rate  *int64
+		}{{fresh, &snapshot.Input}, {fact.CachedInputTokens, snapshot.CachedInput}, {fact.OutputTokens, &snapshot.Output}}
+		if *fact.CacheCreationInputTokens > 0 {
+			if fact.CacheWrite5mTokens == nil {
+				partial = true
+			} else {
+				components = append(components, struct {
+					count int64
+					rate  *int64
+				}{*fact.CacheWrite5mTokens, snapshot.CacheWrite5m}, struct {
+					count int64
+					rate  *int64
+				}{*fact.CacheWrite1hTokens, snapshot.CacheWrite1h})
+			}
+		}
+		for _, component := range components {
+			if component.count == 0 {
+				continue
+			}
+			if component.rate == nil {
+				partial = true
+				continue
+			}
+			amount, ok := roundedTokenCostMicrosSafe(component.count, *component.rate)
+			if !ok {
+				return nil, CostStatusUnknown, nil, nil
+			}
+			cost, ok = addCostMicros(cost, amount)
+			if !ok {
+				return nil, CostStatusUnknown, nil, nil
+			}
+		}
+		status := CostStatusEstimated
+		if partial {
+			status = CostStatusPartial
+		}
+		return &cost, status, &snapshot.Version, snapshot
+	}
+}
+
+func backfillClaudeCodeUsageCosts(ctx context.Context, db *store.Store, sourceID, generation int64) error {
+	return db.BackfillClaudeCodeUsageCosts(ctx, sourceID, generation, claudeCodePricer(pricingSnapshot(ctx)))
+}
diff --git a/internal/usage/claude_code_sync.go b/internal/usage/claude_code_sync.go
new file mode 100644
index 0000000..7e76742
--- /dev/null
+++ b/internal/usage/claude_code_sync.go
@@ -0,0 +1,562 @@
+package usage
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"time"
+
+	"github.com/strahe/profiledeck/internal/apperror"
+	claudeconfig "github.com/strahe/profiledeck/internal/claudecode/config"
+	"github.com/strahe/profiledeck/internal/store"
+)
+
+const (
+	claudeCodeFileUnavailableMessage = "A Claude Code session file could not be imported. It will be checked again after the file changes or when you sync manually."
+	claudeCodeHistoryChangedMessage  = "A Claude Code session file changed before the saved import point. It will be checked again after the file changes or when you sync manually."
+	claudeCodeFactConflictMessage    = "A Claude Code session file conflicts with previously imported usage. It will be checked again after the file changes or when you sync manually."
+)
+
+var errClaudeCodeHistoryChanged = errors.New("claude code usage checkpoint history changed")
+
+type claudeCodeIntegration struct {
+	claudeDir   string
+	provisioner ProviderProvisioner
+}
+
+func NewClaudeCodeIntegrationWithProvisioner(
+	claudeDir string,
+	provisioner ProviderProvisioner,
+) Integration {
+	return claudeCodeIntegration{claudeDir: claudeDir, provisioner: provisioner}
+}
+
+func (claudeCodeIntegration) ProviderID() string {
+	return claudeconfig.ProviderID
+}
+
+func (claudeCodeIntegration) SourceIDs() []string {
+	return []string{SourceClaudeCodeSessionJSONL}
+}
+
+func (claudeCodeIntegration) PricingInfo() UsagePricingInfo {
+	return UsagePricingInfo{
+		Basis:               "anthropic-standard-api",
+		SourceURL:           "https://platform.claude.com/docs/en/about-claude/pricing",
+		VerifiedAt:          "2026-09-28",
+		HistoricalRepricing: false,
+	}
+}
+
+func (integration claudeCodeIntegration) Sync(
+	ctx context.Context,
+	stores store.Factory,
+	options SyncOptions,
+) (SyncOutcome, error) {
+	_, _, _, priceBackfill, noWorkResult, work, err := integration.preflight(ctx, stores, options)
+	if err != nil {
+		return SyncOutcome{}, err
+	}
+	if !work {
+		return SyncOutcome{Result: noWorkResult}, nil
+	}
+	if options.OnWorkDetected != nil {
+		options.OnWorkDetected()
+	}
+	db, err := stores.OpenHealthy(ctx, false)
+	if err != nil {
+		return SyncOutcome{}, err
+	}
+	defer db.Close()
+	source, err := beginClaudeCodeUsageSync(ctx, db, integration.provisioner, options.ProvisionMode)
+	if err != nil {
+		return SyncOutcome{}, err
+	}
+	files, cursors, observed, err := integration.loadSyncSnapshot(ctx, db, source.ID)
+	if err != nil {
+		return SyncOutcome{}, err
+	}
+	result := UsageSyncResult{
+		ProviderID: claudeconfig.ProviderID,
+		Source:     SourceClaudeCodeSessionJSONL,
+	}
+	discoveredFileKeys := make([]store.UsageKey, 0, len(files))
+	observations := make([]store.UsageImportObservation, 0)
+	for _, file := range files {
+		if err := ctx.Err(); err != nil {
+			return SyncOutcome{}, apperror.Wrap(
+				apperror.UsageImportFailed,
+				"usage import canceled",
+				err,
+			)
+		}
+		discoveredFileKeys = append(discoveredFileKeys, file.SourceKey)
+		result.ScannedFiles++
+
+		cursor, hasCursor := cursors[file.SourceKey]
+		if hasCursor && claudeCodeCursorMatchesFile(cursor, file) {
+			result.SkippedUnchangedFiles++
+			continue
+		}
+		if observation, ok := observed[file.SourceKey]; ok &&
+			observation.MetadataDigest == file.MetadataDigest &&
+			observation.ParserRevision == ClaudeCodeUsageParserRevision &&
+			!options.ForceObservedRetry {
+			result.SkippedUnchangedFiles++
+			result.Errors = append(result.Errors, claudeCodeObservationError(observation.Status))
+			continue
+		}
+		if hasCursor && claudeCodeFileIsShorterThanCheckpoint(cursor, file) {
+			result.Errors = append(result.Errors, claudeCodeObservationError(store.UsageImportObservationHistoryChanged))
+			observations = append(observations, newUsageObservation(source.ID, file, ClaudeCodeUsageParserRevision, store.UsageImportObservationHistoryChanged))
+			continue
+		}
+
+		parsed, fullParse, err := parseClaudeCodeUsageChange(ctx, file, cursor, hasCursor, options)
+		if err != nil {
+			if ctxErr := ctx.Err(); ctxErr != nil {
+				return SyncOutcome{}, apperror.Wrap(
+					apperror.UsageImportFailed,
+					"usage import canceled",
+					ctxErr,
+				)
+			}
+			if errors.Is(err, errClaudeCodeHistoryChanged) {
+				result.Errors = append(result.Errors, claudeCodeObservationError(store.UsageImportObservationHistoryChanged))
+				observations = append(observations, newUsageObservation(source.ID, file, ClaudeCodeUsageParserRevision, store.UsageImportObservationHistoryChanged))
+				continue
+			}
+			result.InvalidLines++
+			result.Errors = append(result.Errors, claudeCodeObservationError(store.UsageImportObservationUnavailable))
+			observations = append(observations, newUsageObservation(source.ID, file, ClaudeCodeUsageParserRevision, store.UsageImportObservationUnavailable))
+			continue
+		}
+		eventsToStore := parsed.Events
+		replayExistingFacts := false
+		importedFacts := int64(len(parsed.Events))
+		invalidLines := parsed.InvalidLines
+		unsupportedLines := parsed.UnsupportedLines
+		if hasCursor {
+			if fullParse {
+				eventsToStore = parsed.Events
+				replayExistingFacts = true
+				importedFacts = int64(len(parsed.Events))
+			} else {
+				importedFacts = cursor.ImportedFacts + int64(len(parsed.Events))
+				invalidLines += cursor.InvalidLines
+				unsupportedLines += cursor.UnsupportedLines
+				previousReasons, err := store.DecodeClaudeCodeUsageInvalidReasons(cursor.ParserStateJSON, cursor.InvalidLines)
+				if err != nil {
+					return SyncOutcome{}, err
+				}
+				for reason, count := range previousReasons {
+					parsed.ClaudeInvalidReasons[reason] += count
+				}
+			}
+		}
+
+		parserState, err := json.Marshal(parsed.ClaudeInvalidReasons)
+		if err != nil {
+			return SyncOutcome{}, err
+		}
+		desired := store.ClaudeCodeUsageImportFile{
+			SourceID:              source.ID,
+			FileKey:               file.SourceKey,
+			ModifiedUnixMS:        file.ModifiedUnixMS,
+			SizeBytes:             file.SizeBytes,
+			ImportedFacts:         importedFacts,
+			InvalidLines:          invalidLines,
+			UnsupportedLines:      unsupportedLines,
+			ParserRevision:        ClaudeCodeUsageParserRevision,
+			IdentityRevision:      ClaudeCodeUsageIdentityRevision,
+			EventDigest:           parsed.CheckpointEventDigest,
+			CheckpointRevision:    usageCheckpointRevision,
+			ProcessedBytes:        parsed.ProcessedBytes,
+			MetadataDigest:        file.MetadataDigest,
+			FileIdentityDigest:    file.FileIdentityDigest,
+			BoundaryDigest:        parsed.BoundaryDigest,
+			CheckpointEventDigest: parsed.CheckpointEventDigest,
+			ParserStateJSON:       string(parserState),
+		}
+		var expected *store.ClaudeCodeUsageImportFile
+		if hasCursor {
+			expected = &cursor
+		}
+		insertResult, err := db.CommitClaudeCodeUsageImport(
+			ctx,
+			store.CommitClaudeCodeUsageImportParams{
+				ProviderID:          claudeconfig.ProviderID,
+				Generation:          source.SyncGeneration,
+				Facts:               usageEventsToFactParams(source.ID, eventsToStore),
+				Price:               claudeCodePricer(pricingSnapshot(ctx)),
+				File:                desired,
+				Expected:            expected,
+				ReplayExistingFacts: replayExistingFacts,
+			},
+		)
+		if errors.Is(err, store.ErrUsageCursorConflict) {
+			current, readErr := db.GetClaudeCodeUsageImportFile(ctx, source.ID, file.SourceKey)
+			if readErr == nil && sameClaudeCodeUsageImportProgress(current, desired) {
+				result.SkippedDuplicateEvents += int64(len(eventsToStore))
+				result.UnsupportedLines += unsupportedLines
+				continue
+			}
+			if readErr != nil && !errors.Is(readErr, store.ErrNotFound) {
+				return SyncOutcome{}, apperror.Wrap(
+					apperror.UsageImportFailed,
+					"failed to inspect concurrent usage sync",
+					readErr,
+				)
+			}
+			return SyncOutcome{}, err
+		}
+		if errors.Is(err, store.ErrUsageFactConflict) {
+			result.InvalidLines++
+			result.Errors = append(result.Errors, claudeCodeObservationError(store.UsageImportObservationFactConflict))
+			observations = append(observations, newUsageObservation(source.ID, file, ClaudeCodeUsageParserRevision, store.UsageImportObservationFactConflict))
+			continue
+		}
+		if err != nil {
+			return SyncOutcome{}, err
+		}
+		result.ImportedEvents += int64(insertResult.Inserted)
+		result.UpdatedEvents += int64(insertResult.Updated)
+		result.SkippedDuplicateEvents += int64(insertResult.Duplicates)
+		result.InvalidLines += invalidLines
+		result.UnsupportedLines += unsupportedLines
+	}
+
+	if err := db.CompleteUsageSync(ctx, store.CompleteUsageSyncParams{
+		SourceID:          source.ID,
+		Generation:        source.SyncGeneration,
+		CompletedAtUnixMS: time.Now().UnixMilli(),
+		Finalization: &store.ClaudeCodeUsageSyncFinalization{
+			ProviderID:         claudeconfig.ProviderID,
+			DiscoveredFileKeys: discoveredFileKeys,
+		},
+		Observations: observations,
+	}); err != nil {
+		return SyncOutcome{}, err
+	}
+	if options.ProvisionMode == SyncProvisionProvider || priceBackfill {
+		if err := backfillClaudeCodeUsageCosts(ctx, db, source.ID, source.SyncGeneration); err != nil {
+			return SyncOutcome{}, err
+		}
+	}
+
+	return SyncOutcome{Result: result, Performed: true}, nil
+}
+
+func (integration claudeCodeIntegration) loadSyncSnapshot(
+	ctx context.Context,
+	db *store.Store,
+	sourceID int64,
+) ([]SourceFile, map[store.UsageKey]store.ClaudeCodeUsageImportFile, map[store.UsageKey]store.UsageImportObservation, error) {
+	files, err := ListClaudeCodeSessionFilesContext(ctx, integration.claudeDir)
+	if err != nil {
+		return nil, nil, nil, apperror.Wrap(apperror.UsageImportFailed, "failed to list Claude Code session files", err)
+	}
+	cursorRows, err := db.ListClaudeCodeUsageImportFiles(ctx, sourceID)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	observationRows, err := db.ListUsageImportObservations(ctx, sourceID)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	return files, claudeCodeCursorMap(cursorRows), observationMap(observationRows), nil
+}
+
+func (integration claudeCodeIntegration) preflight(
+	ctx context.Context,
+	stores store.Factory,
+	options SyncOptions,
+) (
+	[]SourceFile,
+	map[store.UsageKey]store.ClaudeCodeUsageImportFile,
+	map[store.UsageKey]store.UsageImportObservation,
+	bool,
+	UsageSyncResult,
+	bool,
+	error,
+) {
+	if options.ProvisionMode == SyncProvisionProvider {
+		files, err := ListClaudeCodeSessionFilesContext(ctx, integration.claudeDir)
+		if err != nil {
+			return nil, nil, nil, false, UsageSyncResult{}, false, apperror.Wrap(
+				apperror.UsageImportFailed,
+				"failed to list Claude Code session files",
+				err,
+			)
+		}
+		result := UsageSyncResult{
+			ProviderID:   claudeconfig.ProviderID,
+			Source:       SourceClaudeCodeSessionJSONL,
+			ScannedFiles: int64(len(files)),
+		}
+		return files, nil, nil, true, result, true, nil
+	}
+	db, err := stores.OpenHealthy(ctx, true)
+	if err != nil {
+		return nil, nil, nil, false, UsageSyncResult{}, false, err
+	}
+	defer db.Close()
+	if integration.provisioner == nil {
+		return nil, nil, nil, false, UsageSyncResult{}, false,
+			errors.New("usage Provider provisioner for Claude Code is required")
+	}
+	if err := integration.provisioner.Ensure(ctx, db, SyncExistingProvider); err != nil {
+		return nil, nil, nil, false, UsageSyncResult{}, false, err
+	}
+	source, err := db.GetUsageSource(ctx, claudeconfig.ProviderID, SourceClaudeCodeSessionJSONL)
+	if errors.Is(err, store.ErrNotFound) {
+		files, listErr := ListClaudeCodeSessionFilesContext(ctx, integration.claudeDir)
+		if listErr != nil {
+			return nil, nil, nil, false, UsageSyncResult{}, false, apperror.Wrap(
+				apperror.UsageImportFailed,
+				"failed to list Claude Code session files",
+				listErr,
+			)
+		}
+		result := UsageSyncResult{
+			ProviderID:   claudeconfig.ProviderID,
+			Source:       SourceClaudeCodeSessionJSONL,
+			ScannedFiles: int64(len(files)),
+		}
+		return files, nil, nil, false, result, true, nil
+	}
+	if err != nil {
+		return nil, nil, nil, false, UsageSyncResult{}, false, err
+	}
+	if source.IdentityRevision != ClaudeCodeUsageIdentityRevision {
+		return nil, nil, nil, false, UsageSyncResult{}, false, store.ErrUsageIdentityRevision
+	}
+	cursorRows, err := db.ListClaudeCodeUsageImportFiles(ctx, source.ID)
+	if err != nil {
+		return nil, nil, nil, false, UsageSyncResult{}, false, err
+	}
+	observationRows, err := db.ListUsageImportObservations(ctx, source.ID)
+	if err != nil {
+		return nil, nil, nil, false, UsageSyncResult{}, false, err
+	}
+	unknownModels, err := db.ListUnknownUsageCostModels(ctx, claudeconfig.ProviderID)
+	if err != nil {
+		return nil, nil, nil, false, UsageSyncResult{}, false, err
+	}
+	files, err := ListClaudeCodeSessionFilesContext(ctx, integration.claudeDir)
+	if err != nil {
+		return nil, nil, nil, false, UsageSyncResult{}, false, apperror.Wrap(
+			apperror.UsageImportFailed,
+			"failed to list Claude Code session files",
+			err,
+		)
+	}
+	result := UsageSyncResult{
+		ProviderID:   claudeconfig.ProviderID,
+		Source:       SourceClaudeCodeSessionJSONL,
+		ScannedFiles: int64(len(files)),
+	}
+	cursors := claudeCodeCursorMap(cursorRows)
+	observations := observationMap(observationRows)
+	catalog := pricingSnapshot(ctx)
+	priceBackfill, err := hasPriceableUnknownUsageModel(ctx, db, unknownModels, catalog, claudeconfig.ProviderID)
+	if err != nil {
+		return nil, nil, nil, false, UsageSyncResult{}, false, err
+	}
+	work := source.SyncGeneration != source.CompletedGeneration || priceBackfill
+	discovered := make(map[store.UsageKey]struct{}, len(files))
+	for _, file := range files {
+		discovered[file.SourceKey] = struct{}{}
+		if cursor, ok := cursors[file.SourceKey]; ok {
+			if cursor.IdentityRevision != ClaudeCodeUsageIdentityRevision {
+				return nil, nil, nil, false, UsageSyncResult{}, false, store.ErrUsageIdentityRevision
+			}
+			if claudeCodeCursorMatchesFile(cursor, file) {
+				result.SkippedUnchangedFiles++
+				continue
+			}
+		}
+		if observation, ok := observations[file.SourceKey]; ok &&
+			observation.MetadataDigest == file.MetadataDigest &&
+			observation.ParserRevision == ClaudeCodeUsageParserRevision &&
+			!options.ForceObservedRetry {
+			result.SkippedUnchangedFiles++
+			result.Errors = append(result.Errors, claudeCodeObservationError(observation.Status))
+			continue
+		}
+		work = true
+	}
+	for key := range cursors {
+		if _, ok := discovered[key]; !ok {
+			work = true
+		}
+	}
+	for key := range observations {
+		if _, ok := discovered[key]; !ok {
+			work = true
+		}
+	}
+	return files, cursors, observations, priceBackfill, result, work, nil
+}
+
+func parseClaudeCodeUsageChange(
+	ctx context.Context,
+	file SourceFile,
+	cursor store.ClaudeCodeUsageImportFile,
+	hasCursor bool,
+	options SyncOptions,
+) (checkpointParseResult, bool, error) {
+	if hasCursor && cursor.CheckpointRevision == usageCheckpointRevision &&
+		cursor.ParserRevision == ClaudeCodeUsageParserRevision &&
+		cursor.IdentityRevision == ClaudeCodeUsageIdentityRevision &&
+		!cursor.FileIdentityDigest.IsZero() &&
+		cursor.FileIdentityDigest == file.FileIdentityDigest &&
+		file.SizeBytes > cursor.SizeBytes {
+		parsed, parseErr := parseClaudeCodeCheckpointFile(
+			ctx,
+			file,
+			cursor.ProcessedBytes,
+			cursor.CheckpointEventDigest,
+			cursor.BoundaryDigest,
+			options.fileSystem,
+			options.Observer,
+			ClaudeCodeUsageParserRevision,
+		)
+		if parseErr == nil {
+			return parsed, false, nil
+		}
+		if !errors.Is(parseErr, errUsageBoundaryChanged) {
+			return checkpointParseResult{}, false, parseErr
+		}
+	}
+	parsed, err := parseClaudeCodeCheckpointFile(
+		ctx,
+		file,
+		0,
+		store.UsageKey{},
+		store.UsageKey{},
+		options.fileSystem,
+		options.Observer,
+		ClaudeCodeUsageParserRevision,
+	)
+	if err != nil || !hasCursor {
+		return parsed, true, err
+	}
+	validationEvents := parsed.Events
+	if cursor.ParserRevision < ClaudeCodeUsageParserRevision {
+		// Validate accepted observations with their original parser before applying new semantics.
+		previous, err := parseClaudeCodeCheckpointFile(ctx, file, 0, store.UsageKey{}, store.UsageKey{}, options.fileSystem, options.Observer, cursor.ParserRevision)
+		if err != nil {
+			return checkpointParseResult{}, true, err
+		}
+		validationEvents = previous.Events
+	}
+	if !claudeCodeCheckpointPrefixMatches(validationEvents, cursor) {
+		return checkpointParseResult{}, true, errClaudeCodeHistoryChanged
+	}
+	return parsed, true, nil
+}
+
+func claudeCodeCheckpointPrefixMatches(events []Event, cursor store.ClaudeCodeUsageImportFile) bool {
+	if cursor.ImportedFacts < 0 || cursor.ImportedFacts > int64(len(events)) ||
+		cursor.IdentityRevision != ClaudeCodeUsageIdentityRevision {
+		return false
+	}
+	return cursor.CheckpointRevision == usageCheckpointRevision &&
+		checkpointEventDigest(claudeconfig.ProviderID, events, cursor.ImportedFacts) == cursor.CheckpointEventDigest
+}
+
+func claudeCodeCursorMatchesFile(cursor store.ClaudeCodeUsageImportFile, file SourceFile) bool {
+	if cursor.ParserRevision != ClaudeCodeUsageParserRevision ||
+		cursor.IdentityRevision != ClaudeCodeUsageIdentityRevision {
+		return false
+	}
+	if cursor.CheckpointRevision == usageCheckpointRevision {
+		return cursor.MetadataDigest == file.MetadataDigest
+	}
+	return cursor.CheckpointRevision == 0 &&
+		cursor.ModifiedUnixMS == file.ModifiedUnixMS && cursor.SizeBytes == file.SizeBytes
+}
+
+func claudeCodeFileIsShorterThanCheckpoint(cursor store.ClaudeCodeUsageImportFile, file SourceFile) bool {
+	if cursor.CheckpointRevision == usageCheckpointRevision {
+		return file.SizeBytes < cursor.ProcessedBytes
+	}
+	return file.SizeBytes < cursor.SizeBytes
+}
+
+func claudeCodeCursorMap(rows []store.ClaudeCodeUsageImportFile) map[store.UsageKey]store.ClaudeCodeUsageImportFile {
+	result := make(map[store.UsageKey]store.ClaudeCodeUsageImportFile, len(rows))
+	for _, row := range rows {
+		result[row.FileKey] = row
+	}
+	return result
+}
+
+func claudeCodeObservationError(status store.UsageImportObservationStatus) UsageImportError {
+	message := claudeCodeFileUnavailableMessage
+	switch status {
+	case store.UsageImportObservationHistoryChanged:
+		message = claudeCodeHistoryChangedMessage
+	case store.UsageImportObservationFactConflict:
+		message = claudeCodeFactConflictMessage
+	}
+	return UsageImportError{Message: message}
+}
+
+func beginClaudeCodeUsageSync(
+	ctx context.Context,
+	db *store.Store,
+	provisioner ProviderProvisioner,
+	mode SyncProvisionMode,
+) (store.UsageSource, error) {
+	var source store.UsageSource
+	err := db.WithTransaction(ctx, func(txStore *store.Store) error {
+		if provisioner == nil {
+			return errors.New("usage Provider provisioner for Claude Code is required")
+		}
+		if err := provisioner.Ensure(ctx, txStore, mode); err != nil {
+			return err
+		}
+		var err error
+		source, err = txStore.BeginUsageSync(
+			ctx,
+			claudeconfig.ProviderID,
+			SourceClaudeCodeSessionJSONL,
+			ClaudeCodeUsageIdentityRevision,
+		)
+		if err != nil {
+			return err
+		}
+		return txStore.ValidateClaudeCodeUsageImportIdentity(
+			ctx,
+			source.ID,
+			claudeconfig.ProviderID,
+			ClaudeCodeUsageIdentityRevision,
+		)
+	})
+	return source, err
+}
+
+func sameClaudeCodeUsageImportProgress(
+	left store.ClaudeCodeUsageImportFile,
+	right store.ClaudeCodeUsageImportFile,
+) bool {
+	return left.SourceID == right.SourceID &&
+		left.FileKey == right.FileKey &&
+		left.ModifiedUnixMS == right.ModifiedUnixMS &&
+		left.SizeBytes == right.SizeBytes &&
+		left.ImportedFacts == right.ImportedFacts &&
+		left.InvalidLines == right.InvalidLines &&
+		left.UnsupportedLines == right.UnsupportedLines &&
+		left.ParserRevision == right.ParserRevision &&
+		left.IdentityRevision == right.IdentityRevision &&
+		left.EventDigest == right.EventDigest &&
+		left.CheckpointRevision == right.CheckpointRevision &&
+		left.ProcessedBytes == right.ProcessedBytes &&
+		left.MetadataDigest == right.MetadataDigest &&
+		left.FileIdentityDigest == right.FileIdentityDigest &&
+		left.BoundaryDigest == right.BoundaryDigest &&
+		left.CheckpointEventDigest == right.CheckpointEventDigest &&
+		left.ParserStateJSON == right.ParserStateJSON
+}
diff --git a/internal/usage/claude_code_test.go b/internal/usage/claude_code_test.go
new file mode 100644
index 0000000..de7c1c2
--- /dev/null
+++ b/internal/usage/claude_code_test.go
@@ -0,0 +1,727 @@
+package usage
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"maps"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/strahe/profiledeck/internal/pricing"
+	"github.com/strahe/profiledeck/internal/store"
+)
+
+func claudeUsageLine(session, request string, final bool, output int64) []byte {
+	var stop any
+	if final {
+		stop = "end_turn"
+	}
+	usage := map[string]any{"input_tokens": 70, "cache_read_input_tokens": 20, "cache_creation_input_tokens": 10, "output_tokens": output, "cache_creation": map[string]any{"ephemeral_5m_input_tokens": 0, "ephemeral_1h_input_tokens": 10}}
+	data, _ := json.Marshal(map[string]any{"type": "assistant", "sessionId": session, "requestId": request, "timestamp": "2026-09-24T12:00:00Z", "message": map[string]any{"id": "message-" + request, "model": "claude-opus-5-5", "stop_reason": stop, "usage": usage}})
+	return append(data, '\n')
+}
+
+func claudeZeroedHistoryLine(t *testing.T, retainedDetails bool) []byte {
+	t.Helper()
+	var record map[string]any
+	if err := json.Unmarshal(claudeUsageLine("fork", "request", true, 30), &record); err != nil {
+		t.Fatal(err)
+	}
+	usage := record["message"].(map[string]any)["usage"].(map[string]any)
+	if retainedDetails {
+		iteration := maps.Clone(usage)
+		iteration["type"] = "message"
+		usage["iterations"] = []any{iteration}
+	} else {
+		delete(usage, "cache_creation")
+	}
+	for _, field := range []string{"input_tokens", "cache_read_input_tokens", "cache_creation_input_tokens", "output_tokens"} {
+		usage[field] = 0
+	}
+	line, err := json.Marshal(record)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return append(line, '\n')
+}
+
+func importClaudeCodeTestFile(t *testing.T, ctx context.Context, db *store.Store, source store.UsageSource, file SourceFile, revision int64, price store.ClaudeCodeUsagePricer) store.ClaudeCodeUsageImportFile {
+	t.Helper()
+	parsed, err := parseClaudeCodeCheckpointFile(ctx, file, 0, store.UsageKey{}, store.UsageKey{}, nil, nil, revision)
+	if err != nil {
+		t.Fatal(err)
+	}
+	state, err := json.Marshal(parsed.ClaudeInvalidReasons)
+	if err != nil {
+		t.Fatal(err)
+	}
+	cursor := store.ClaudeCodeUsageImportFile{
+		SourceID: source.ID, FileKey: file.SourceKey,
+		ModifiedUnixMS: file.ModifiedUnixMS, SizeBytes: file.SizeBytes,
+		ImportedFacts: int64(len(parsed.Events)), InvalidLines: parsed.InvalidLines, UnsupportedLines: parsed.UnsupportedLines,
+		ParserRevision: revision, IdentityRevision: ClaudeCodeUsageIdentityRevision,
+		EventDigest: parsed.CheckpointEventDigest, CheckpointRevision: usageCheckpointRevision,
+		ProcessedBytes: parsed.ProcessedBytes, MetadataDigest: file.MetadataDigest,
+		FileIdentityDigest: file.FileIdentityDigest, BoundaryDigest: parsed.BoundaryDigest,
+		CheckpointEventDigest: parsed.CheckpointEventDigest, ParserStateJSON: string(state),
+	}
+	if _, err := db.CommitClaudeCodeUsageImport(ctx, store.CommitClaudeCodeUsageImportParams{
+		ProviderID: "claude-code", Generation: source.SyncGeneration,
+		Facts: usageEventsToFactParams(source.ID, parsed.Events), File: cursor, Price: price,
+	}); err != nil {
+		t.Fatal(err)
+	}
+	cursor, err = db.GetClaudeCodeUsageImportFile(ctx, source.ID, file.SourceKey)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return cursor
+}
+
+func TestClaudeCodeParserValidatesCandidatesWithoutUsingEarlyOutput(t *testing.T) {
+	line := claudeUsageLine("parent", "request", false, 1)
+	event, invalid, unsupported, err := parseClaudeCodeSessionLine(line)
+	if err != nil || invalid || unsupported || event == nil || event.OutputTokens != 0 || event.TotalTokens != 100 || event.TokenStatus != store.UsageTokensPartial {
+		t.Fatalf("partial: %+v, %t, %t, %v", event, invalid, unsupported, err)
+	}
+	var record map[string]any
+	if err := json.Unmarshal(line, &record); err != nil {
+		t.Fatal(err)
+	}
+	message := record["message"].(map[string]any)
+	u := message["usage"].(map[string]any)
+	message["stop_reason"] = "end_turn"
+	u["cache_creation_input_tokens"] = 0
+	bad, _ := json.Marshal(record)
+	if event, reason, _, err := parseClaudeCodeSessionObservation(bad); err != nil || reason != store.ClaudeCodeCacheMismatch || event != nil {
+		t.Fatalf("inconsistent cache accepted or misclassified: %+v, %s, %v", event, reason, err)
+	}
+	u["cache_creation_input_tokens"] = 10
+	u["iterations"] = []any{map[string]any{"type": "message", "input_tokens": 70, "cache_read_input_tokens": 20, "cache_creation_input_tokens": 10, "output_tokens": 99}}
+	bad, _ = json.Marshal(record)
+	if event, reason, _, err := parseClaudeCodeSessionObservation(bad); err != nil || reason != store.ClaudeCodeIterationMismatch || event != nil {
+		t.Fatalf("inconsistent iteration accepted or misclassified: %+v, %s, %v", event, reason, err)
+	}
+	delete(u, "iterations")
+	delete(record, "requestId")
+	bad, _ = json.Marshal(record)
+	if event, _, unsupported, err := parseClaudeCodeSessionLine(bad); err != nil || !unsupported || event != nil {
+		t.Fatalf("missing identity accepted: %+v, %t, %v", event, unsupported, err)
+	}
+	cached := bytes.Replace(claudeUsageLine("session", "cached", true, 30), []byte(`"input_tokens":70`), []byte(`"input_tokens":0`), 1)
+	cached = bytes.Replace(cached, []byte(`"end_turn"`), []byte(`"model_context_window_exceeded"`), 1)
+	event, reason, unsupported, err := parseClaudeCodeSessionObservation(cached)
+	if err != nil || reason != "" || unsupported || event == nil {
+		t.Fatalf("cached context-limit response rejected: %+v, %s, %t, %v", event, reason, unsupported, err)
+	}
+	if event.TokenStatus != store.UsageTokensComplete || event.InputTokens != 30 || event.OutputTokens != 30 {
+		t.Fatalf("cached context-limit response lost usage: %+v", event)
+	}
+	for _, retainedDetails := range []bool{false, true} {
+		event, reason, unsupported, err := parseClaudeCodeSessionObservation(claudeZeroedHistoryLine(t, retainedDetails))
+		if err != nil || reason != "" || unsupported || event != nil {
+			t.Fatalf("zeroed history became a usage candidate: %+v, %s, %t, %v", event, reason, unsupported, err)
+		}
+	}
+}
+
+type claudeTestProvisioner struct{}
+
+func (claudeTestProvisioner) Ensure(ctx context.Context, db *store.Store, mode SyncProvisionMode) error {
+	if mode == SyncExistingProvider {
+		_, err := db.GetProvider(ctx, "claude-code")
+		return err
+	}
+	_, _, err := db.CreateProviderIfMissing(ctx, store.CreateProviderParams{ID: "claude-code", Name: "Claude Code", AdapterID: "claude-code-official-oauth", MetadataJSON: "{}"})
+	return err
+}
+
+func TestClaudeCodeSyncCompletesAcrossRestartWithFrozenPricingAndRetractsConflict(t *testing.T) {
+	ctx := context.Background()
+	factory := store.NewFactory(filepath.Join(t.TempDir(), "profiledeck.db"))
+	db, err := factory.Open(ctx, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	if _, err := db.Migrate(ctx); err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	project := filepath.Join(dir, "projects", "project")
+	if err := os.MkdirAll(project, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	path := filepath.Join(project, "parent.jsonl")
+	if err := os.WriteFile(filepath.Join(project, "a-history.jsonl"), claudeZeroedHistoryLine(t, false), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(path, claudeUsageLine("parent", "request", false, 1), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	integration := NewClaudeCodeIntegrationWithProvisioner(dir, claudeTestProvisioner{})
+	first, err := integration.Sync(ctx, factory, SyncOptions{ProvisionMode: SyncProvisionProvider})
+	if err != nil || first.Result.ImportedEvents != 1 {
+		t.Fatalf("initial: %+v, %v", first, err)
+	}
+	registry, err := NewRegistry(integration)
+	if err != nil {
+		t.Fatal(err)
+	}
+	service := NewService(factory, registry)
+	summary, err := service.Summary(ctx, UsageSummaryRequest{ProviderID: "claude-code"})
+	if err != nil || summary.KnownEstimatedCostUSD != "0.000364" {
+		t.Fatalf("partial cost subtotal: %+v, %v", summary, err)
+	}
+	report, err := service.Report(ctx, UsageReportRequest{ProviderID: "claude-code", Range: UsageRangeAll})
+	if err != nil || report.Summary.TotalTokens != 100 || report.Summary.OutputTokensStatus != "unknown" || report.Summary.IncompleteEventCount != 1 || report.Summary.MissingOutputCostEventCount != 1 || report.Summary.MissingCacheTTLEventCount != 0 || report.Summary.MissingCacheRateEventCount != 0 || report.Summary.KnownEstimatedCostUSD != "0.000364" {
+		t.Fatalf("partial report: %+v, %v", report.Summary, err)
+	}
+	catalog := pricing.Embedded()
+	catalog.CatalogVersion++
+	for i := range catalog.Entries {
+		if catalog.Entries[i].Model == "claude-opus-5-5" {
+			catalog.Entries[i].ShortContext.Output = "99"
+		}
+	}
+	appendFile, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0o600)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := appendFile.Write(claudeUsageLine("parent", "request", true, 30)); err != nil {
+		t.Fatal(err)
+	}
+	if err := appendFile.Close(); err != nil {
+		t.Fatal(err)
+	}
+	integration = NewClaudeCodeIntegrationWithProvisioner(dir, claudeTestProvisioner{})
+	completed, err := integration.Sync(withPricingSnapshot(ctx, catalog), factory, SyncOptions{ProvisionMode: SyncExistingProvider})
+	if err != nil || completed.Result.UpdatedEvents != 1 {
+		t.Fatalf("complete: %+v, %v", completed, err)
+	}
+	report, err = service.Report(ctx, UsageReportRequest{ProviderID: "claude-code", Range: UsageRangeAll})
+	if err != nil || report.Summary.TotalTokens != 130 || report.Summary.TokenTotalStatus != "complete" || report.Summary.MissingOutputCostEventCount != 0 || report.Summary.KnownEstimatedCostUSD != "0.000964" {
+		t.Fatalf("frozen estimate: %+v, %v", report.Summary, err)
+	}
+	childDir := filepath.Join(project, "fork", "subagents")
+	if err := os.MkdirAll(childDir, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(childDir, "agent-copy.jsonl"), claudeUsageLine("fork", "request", true, 30), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(childDir, "agent-zeroed.jsonl"), claudeZeroedHistoryLine(t, true), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := integration.Sync(ctx, factory, SyncOptions{ProvisionMode: SyncExistingProvider}); err != nil {
+		t.Fatal(err)
+	}
+	report, err = service.Report(ctx, UsageReportRequest{ProviderID: "claude-code", Range: UsageRangeAll})
+	if err != nil || report.Summary.EventCount != 1 || report.Summary.TotalTokens != 130 {
+		t.Fatalf("fork counted twice: %+v, %v", report.Summary, err)
+	}
+	if report.Import.InvalidLines != 0 || report.Import.UnsupportedLines != 0 || report.Summary.ConflictingEventCount != 0 {
+		t.Fatalf("history copies caused a quality warning: %+v, %+v", report.Import, report.Summary)
+	}
+	if err := os.WriteFile(filepath.Join(project, "conflict.jsonl"), claudeUsageLine("other", "request", true, 40), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := integration.Sync(ctx, factory, SyncOptions{ProvisionMode: SyncExistingProvider}); err != nil {
+		t.Fatal(err)
+	}
+	report, err = service.Report(ctx, UsageReportRequest{ProviderID: "claude-code", Range: UsageRangeAll})
+	if err != nil || report.Summary.TotalTokens != 0 || report.Summary.ConflictingEventCount != 1 || report.Summary.TokenTotalStatus != "unknown" || report.Summary.KnownEstimatedCostUSD != "0.000000" {
+		t.Fatalf("conflict not retracted: %+v, %v", report.Summary, err)
+	}
+}
+
+func TestClaudeCodePricingDistinguishesCacheDurationAndUnknownTTL(t *testing.T) {
+	catalog := pricing.Embedded()
+	for _, test := range []struct {
+		ttl    string
+		want   int64
+		status store.UsageCostStatus
+	}{{"1h", 364, CostStatusEstimated}, {"5m", 334, CostStatusEstimated}, {"missing", 284, CostStatusPartial}} {
+		event, _, _, err := parseClaudeCodeSessionLine(claudeUsageLine("session", "request", true, 0))
+		if err != nil {
+			t.Fatal(err)
+		}
+		fact := usageEventsToFactParams(1, []Event{*event})[0]
+		if test.ttl == "5m" {
+			fact.CacheWrite5mTokens = fact.CacheCreationInputTokens
+			zero := int64(0)
+			fact.CacheWrite1hTokens = &zero
+		}
+		if test.ttl == "missing" {
+			fact.CacheWrite5mTokens = nil
+			fact.CacheWrite1hTokens = nil
+		}
+		cost, status, _, _ := claudeCodePricer(catalog)(fact)
+		if cost == nil || *cost != test.want || status != test.status {
+			t.Fatalf("%s: %v, %v", test.ttl, cost, status)
+		}
+	}
+}
+
+func TestClaudeCodeCostBackfillCannotBorrowANewerSyncGeneration(t *testing.T) {
+	ctx := context.Background()
+	factory := store.NewFactory(filepath.Join(t.TempDir(), "profiledeck.db"))
+	db, err := factory.Open(ctx, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	if _, err := db.Migrate(ctx); err != nil {
+		t.Fatal(err)
+	}
+	source, err := beginClaudeCodeUsageSync(ctx, db, claudeTestProvisioner{}, SyncProvisionProvider)
+	if err != nil {
+		t.Fatal(err)
+	}
+	event, _, _, err := parseClaudeCodeSessionLine(claudeUsageLine("session", "request", true, 30))
+	if err != nil || event == nil {
+		t.Fatalf("parse fixture: %+v, %v", event, err)
+	}
+	dir := t.TempDir()
+	project := filepath.Join(dir, "projects", "project")
+	if err := os.MkdirAll(project, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(project, "session.jsonl"), claudeUsageLine("session", "request", true, 30), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	files, err := ListClaudeCodeSessionFilesContext(ctx, dir)
+	if err != nil || len(files) != 1 {
+		t.Fatalf("discover fixture: %d files, %v", len(files), err)
+	}
+	importClaudeCodeTestFile(t, ctx, db, source, files[0], ClaudeCodeUsageParserRevision, nil)
+	if err := db.CompleteUsageSync(ctx, store.CompleteUsageSyncParams{
+		SourceID: source.ID, Generation: source.SyncGeneration, CompletedAtUnixMS: event.OccurredAtUnixMS,
+		Finalization: &store.ClaudeCodeUsageSyncFinalization{ProviderID: "claude-code", DiscoveredFileKeys: []store.UsageKey{files[0].SourceKey}},
+	}); err != nil {
+		t.Fatal(err)
+	}
+	newSource, err := db.BeginUsageSync(ctx, "claude-code", SourceClaudeCodeSessionJSONL, ClaudeCodeUsageIdentityRevision)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := backfillClaudeCodeUsageCosts(ctx, db, source.ID, source.SyncGeneration); !errors.Is(err, store.ErrUsageSyncSuperseded) {
+		t.Fatalf("superseded backfill wrote with a newer generation: %v", err)
+	}
+	summary, err := db.UsageSummary(ctx, "claude-code")
+	if err != nil || summary.UnknownCostEvents != 1 || summary.EstimatedCostMicros != 0 {
+		t.Fatalf("superseded backfill changed costs: %+v, %v", summary, err)
+	}
+	catalog := pricing.Embedded()
+	catalog.CatalogVersion++
+	for i := range catalog.Entries {
+		if catalog.Entries[i].Model == "claude-opus-5-5" {
+			catalog.Entries[i].ShortContext.Output = "99"
+		}
+	}
+	if err := backfillClaudeCodeUsageCosts(withPricingSnapshot(ctx, catalog), db, newSource.ID, newSource.SyncGeneration); err != nil {
+		t.Fatal(err)
+	}
+	summary, err = db.UsageSummary(ctx, "claude-code")
+	if err != nil || summary.EstimatedCostMicros != 3334 || summary.UnknownCostEvents != 0 {
+		t.Fatalf("current backfill did not retain its own prices: %+v, %v", summary, err)
+	}
+}
+
+func TestClaudeCodeSyncDoesNotBackfillIneligibleUsageInAPriceablePeriod(t *testing.T) {
+	ctx := context.Background()
+	factory := store.NewFactory(filepath.Join(t.TempDir(), "profiledeck.db"))
+	db, err := factory.Open(ctx, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	if _, err := db.Migrate(ctx); err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	project := filepath.Join(dir, "projects", "project")
+	if err := os.MkdirAll(project, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	content := bytes.Replace(claudeUsageLine("session", "before-prices", true, 30), []byte("2026-09-24"), []byte("2026-09-21"), 1)
+	for _, field := range []string{`"speed":"fast"`, `"inference_geo":"us"`, `"server_tool_use":{"web_search_requests":1}`} {
+		line := claudeUsageLine("session", field, true, 30)
+		line = bytes.Replace(line, []byte(`"input_tokens":70`), []byte(field+`,"input_tokens":70`), 1)
+		content = append(content, line...)
+	}
+	if err := os.WriteFile(filepath.Join(project, "session.jsonl"), content, 0o600); err != nil {
+		t.Fatal(err)
+	}
+	integration := NewClaudeCodeIntegrationWithProvisioner(dir, claudeTestProvisioner{})
+	if _, err := integration.Sync(ctx, factory, SyncOptions{ProvisionMode: SyncProvisionProvider}); err != nil {
+		t.Fatal(err)
+	}
+	source, err := db.GetUsageSource(ctx, "claude-code", SourceClaudeCodeSessionJSONL)
+	if err != nil {
+		t.Fatal(err)
+	}
+	work := false
+	outcome, err := integration.Sync(ctx, factory, SyncOptions{ProvisionMode: SyncExistingProvider, OnWorkDetected: func() { work = true }})
+	if err != nil || outcome.Performed || work {
+		t.Fatalf("ineligible usage triggered an empty backfill: %+v, work=%t, %v", outcome, work, err)
+	}
+	current, err := db.GetUsageSource(ctx, "claude-code", SourceClaudeCodeSessionJSONL)
+	if err != nil || current.SyncGeneration != source.SyncGeneration {
+		t.Fatalf("empty backfill advanced the source generation: %+v, %v", current, err)
+	}
+	summary, err := db.UsageSummary(ctx, "claude-code")
+	if err != nil || summary.EventCount != 4 || summary.UnknownCostEvents != 4 {
+		t.Fatalf("unknown usage was lost or estimated: %+v, %v", summary, err)
+	}
+}
+
+func TestClaudeCodeParserUpgradeVerifiesOldHistoryAndCompletesSupportedResponses(t *testing.T) {
+	for _, rewritten := range []bool{false, true} {
+		name := "unchanged"
+		if rewritten {
+			name = "rewritten"
+		}
+		t.Run(name, func(t *testing.T) {
+			ctx := context.Background()
+			factory := store.NewFactory(filepath.Join(t.TempDir(), "profiledeck.db"))
+			db, err := factory.Open(ctx, false)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer db.Close()
+			if _, err := db.Migrate(ctx); err != nil {
+				t.Fatal(err)
+			}
+			dir := t.TempDir()
+			project := filepath.Join(dir, "projects", "project")
+			if err := os.MkdirAll(project, 0o700); err != nil {
+				t.Fatal(err)
+			}
+			path := filepath.Join(project, "session.jsonl")
+			content := claudeUsageLine("session", "request", false, 1)
+			contextLimit := bytes.Replace(claudeUsageLine("session", "request", true, 30), []byte(`"end_turn"`), []byte(`"model_context_window_exceeded"`), 1)
+			content = append(content, contextLimit...)
+			content = append(content, claudeZeroedHistoryLine(t, true)...)
+			content = append(content, claudeUsageLine("session", "next", true, 30)...)
+			if err := os.WriteFile(path, content, 0o600); err != nil {
+				t.Fatal(err)
+			}
+			source, err := beginClaudeCodeUsageSync(ctx, db, claudeTestProvisioner{}, SyncProvisionProvider)
+			if err != nil {
+				t.Fatal(err)
+			}
+			files, err := ListClaudeCodeSessionFilesContext(ctx, dir)
+			if err != nil || len(files) != 1 {
+				t.Fatalf("discover fixture: %d files, %v", len(files), err)
+			}
+			cursor := importClaudeCodeTestFile(t, ctx, db, source, files[0], 2, claudeCodePricer(pricing.Embedded()))
+			if cursor.InvalidLines != 1 || cursor.UnsupportedLines != 1 || cursor.ImportedFacts != 2 {
+				t.Fatalf("legacy fixture did not reproduce rejected history: %+v", cursor)
+			}
+			if err := db.CompleteUsageSync(ctx, store.CompleteUsageSyncParams{
+				SourceID: source.ID, Generation: source.SyncGeneration, CompletedAtUnixMS: 1,
+				Finalization: &store.ClaudeCodeUsageSyncFinalization{ProviderID: "claude-code", DiscoveredFileKeys: []store.UsageKey{files[0].SourceKey}},
+			}); err != nil {
+				t.Fatal(err)
+			}
+			if rewritten {
+				content = bytes.Replace(content, []byte(`"input_tokens":70`), []byte(`"input_tokens":71`), 1)
+				if err := os.WriteFile(path, content, 0o600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			integration := NewClaudeCodeIntegrationWithProvisioner(dir, claudeTestProvisioner{})
+			outcome, err := integration.Sync(ctx, factory, SyncOptions{ProvisionMode: SyncExistingProvider})
+			if err != nil {
+				t.Fatal(err)
+			}
+			current, err := db.GetClaudeCodeUsageImportFile(ctx, source.ID, files[0].SourceKey)
+			if err != nil {
+				t.Fatal(err)
+			}
+			summary, err := db.UsageSummary(ctx, "claude-code")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if rewritten {
+				if len(outcome.Result.Errors) != 1 || outcome.Result.UpdatedEvents != 0 || !sameClaudeCodeUsageImportProgress(current, cursor) {
+					t.Fatalf("upgrade accepted rewritten history: %+v, %+v", outcome, current)
+				}
+				if summary.TotalTokens != 230 || summary.EstimatedCostMicros != 1328 || summary.IncompleteEventCount != 1 {
+					t.Fatalf("rewritten history changed accepted usage: %+v", summary)
+				}
+				return
+			}
+			if len(outcome.Result.Errors) != 0 || outcome.Result.UpdatedEvents != 1 || current.ParserRevision != ClaudeCodeUsageParserRevision {
+				t.Fatalf("upgrade failed to complete supported usage: %+v, %+v", outcome, current)
+			}
+			if current.InvalidLines != 0 || current.UnsupportedLines != 0 || current.ImportedFacts != 3 {
+				t.Fatalf("upgrade retained obsolete warnings: %+v", current)
+			}
+			if summary.TotalTokens != 260 || summary.EstimatedCostMicros != 1928 || summary.IncompleteEventCount != 0 || summary.ConflictingEventCount != 0 {
+				t.Fatalf("upgraded totals: %+v", summary)
+			}
+			noWork, err := integration.Sync(ctx, factory, SyncOptions{ProvisionMode: SyncExistingProvider})
+			if err != nil || noWork.Performed {
+				t.Fatalf("upgraded checkpoint was not stable: %+v, %v", noWork, err)
+			}
+		})
+	}
+}
+
+func TestClaudeCodeSyncRetainsAcceptedHistoryAndWaitsForTail(t *testing.T) {
+	ctx := context.Background()
+	factory := store.NewFactory(filepath.Join(t.TempDir(), "profiledeck.db"))
+	db, err := factory.Open(ctx, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	if _, err := db.Migrate(ctx); err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	project := filepath.Join(dir, "projects", "project")
+	if err := os.MkdirAll(project, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	path := filepath.Join(project, "session.jsonl")
+	partial := claudeUsageLine("session", "request", false, 1)
+	final := claudeUsageLine("session", "request", true, 30)
+	malformed := []byte("{broken-json}\n")
+	invalid := append(malformed, bytes.Replace(final, []byte(`"input_tokens":70`), []byte(`"input_tokens":"invalid"`), 1)...)
+	tailAt := len(final) / 2
+	prefix := append(append(append([]byte{}, partial...), invalid...), final[:tailAt]...)
+	if err := os.WriteFile(path, prefix, 0o600); err != nil {
+		t.Fatal(err)
+	}
+	integration := NewClaudeCodeIntegrationWithProvisioner(dir, claudeTestProvisioner{})
+	first, err := integration.Sync(ctx, factory, SyncOptions{ProvisionMode: SyncProvisionProvider})
+	if err != nil || first.Result.InvalidLines != 2 || first.Result.ImportedEvents != 1 {
+		t.Fatalf("initial: %+v, %v", first, err)
+	}
+	source, err := db.GetUsageSource(ctx, "claude-code", SourceClaudeCodeSessionJSONL)
+	if err != nil {
+		t.Fatal(err)
+	}
+	key, err := SourceKey(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	cursor, err := db.GetClaudeCodeUsageImportFile(ctx, source.ID, key)
+	if err != nil || cursor.ProcessedBytes != int64(len(partial)+len(invalid)) {
+		t.Fatalf("tail advanced: %+v, %v", cursor, err)
+	}
+	reasons, err := store.DecodeClaudeCodeUsageInvalidReasons(cursor.ParserStateJSON, cursor.InvalidLines)
+	if err != nil || reasons[store.ClaudeCodeInvalidJSON] != 1 || reasons[store.ClaudeCodeInvalidFields] != 1 {
+		t.Fatalf("invalid reasons: %+v, %v", reasons, err)
+	}
+	if err := os.WriteFile(path, append(prefix, final[tailAt:]...), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	completed, err := integration.Sync(ctx, factory, SyncOptions{ProvisionMode: SyncExistingProvider})
+	if err != nil || completed.Result.UpdatedEvents != 1 {
+		t.Fatalf("completion: %+v, %v", completed, err)
+	}
+	cursor, err = db.GetClaudeCodeUsageImportFile(ctx, source.ID, key)
+	if err != nil {
+		t.Fatal(err)
+	}
+	registry, err := NewRegistry(integration)
+	if err != nil {
+		t.Fatal(err)
+	}
+	report, err := NewService(factory, registry).Report(ctx, UsageReportRequest{ProviderID: "claude-code", Range: UsageRangeAll})
+	if err != nil || report.Import.InvalidReasons[store.ClaudeCodeInvalidJSON] != 1 || report.Import.InvalidReasons[store.ClaudeCodeInvalidFields] != 1 {
+		t.Fatalf("reported reasons after append: %+v, %v", report.Import, err)
+	}
+	integrity, err := db.InspectIntegrity(ctx, store.IntegrityCurrentBaseline)
+	if err != nil || len(integrity.Issues) != 0 {
+		t.Fatalf("diagnostic integrity: %+v, %v", integrity, err)
+	}
+	work := false
+	noWork, err := integration.Sync(ctx, factory, SyncOptions{ProvisionMode: SyncExistingProvider, OnWorkDetected: func() { work = true }})
+	if err != nil || noWork.Performed || work {
+		t.Fatalf("unchanged round: %+v, work=%t, %v", noWork, work, err)
+	}
+	for _, content := range [][]byte{
+		bytes.Replace(append(append(append([]byte{}, partial...), invalid...), final...), []byte(`"input_tokens":70`), []byte(`"input_tokens":71`), 1),
+		partial,
+	} {
+		if err := os.WriteFile(path, content, 0o600); err != nil {
+			t.Fatal(err)
+		}
+		changed, err := integration.Sync(ctx, factory, SyncOptions{ProvisionMode: SyncExistingProvider})
+		if err != nil || len(changed.Result.Errors) != 1 {
+			t.Fatalf("changed history accepted: %+v, %v", changed, err)
+		}
+		accepted, err := db.GetClaudeCodeUsageImportFile(ctx, source.ID, key)
+		if err != nil || !sameClaudeCodeUsageImportProgress(accepted, cursor) {
+			t.Fatalf("checkpoint changed: %+v, %v", accepted, err)
+		}
+		summary, err := db.UsageSummary(ctx, "claude-code")
+		if err != nil || summary.TotalTokens != 130 || summary.IncompleteEventCount != 0 {
+			t.Fatalf("accepted facts changed: %+v, %v", summary, err)
+		}
+	}
+}
+
+func TestClaudeCodeReportSeparatesMissingOutputCacheDurationAndRates(t *testing.T) {
+	ctx := context.Background()
+	factory := store.NewFactory(filepath.Join(t.TempDir(), "profiledeck.db"))
+	db, err := factory.Open(ctx, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	if _, err := db.Migrate(ctx); err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	project := filepath.Join(dir, "projects", "project")
+	if err := os.MkdirAll(project, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	integration := NewClaudeCodeIntegrationWithProvisioner(dir, claudeTestProvisioner{})
+	if err := os.WriteFile(filepath.Join(project, "partial.jsonl"), claudeUsageLine("session", "partial", false, 8), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := integration.Sync(ctx, factory, SyncOptions{ProvisionMode: SyncProvisionProvider}); err != nil {
+		t.Fatal(err)
+	}
+	var record map[string]any
+	if err := json.Unmarshal(claudeUsageLine("session", "ttl", true, 30), &record); err != nil {
+		t.Fatal(err)
+	}
+	delete(record["message"].(map[string]any)["usage"].(map[string]any), "cache_creation")
+	missingTTL, err := json.Marshal(record)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(project, "ttl.jsonl"), append(missingTTL, '\n'), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(project, "rate.jsonl"), claudeUsageLine("session", "rate", true, 30), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	catalog := pricing.Embedded()
+	for i := range catalog.Entries {
+		catalog.Entries[i].ShortContext.CacheWrite1h = nil
+	}
+	if _, err := integration.Sync(withPricingSnapshot(ctx, catalog), factory, SyncOptions{ProvisionMode: SyncExistingProvider}); err != nil {
+		t.Fatal(err)
+	}
+	registry, err := NewRegistry(integration)
+	if err != nil {
+		t.Fatal(err)
+	}
+	report, err := NewService(factory, registry).Report(ctx, UsageReportRequest{ProviderID: "claude-code", Range: UsageRangeAll})
+	if err != nil {
+		t.Fatal(err)
+	}
+	summaries := []UsageAggregateSummary{report.Summary, report.Models[0].Summary}
+	for _, point := range report.Trend {
+		if point.Summary.EventCount > 0 {
+			summaries = append(summaries, point.Summary)
+		}
+	}
+	for _, summary := range summaries {
+		if summary.PartialCostEventCount != 3 || summary.MissingOutputCostEventCount != 1 || summary.MissingCacheTTLEventCount != 1 || summary.MissingCacheRateEventCount != 1 {
+			t.Fatalf("cost causes: %+v", summary)
+		}
+	}
+}
+
+func TestClaudeCodeDiscoveryExcludesSymlinksAndNestedNonSessionLogs(t *testing.T) {
+	ctx := context.Background()
+	dir := t.TempDir()
+	project := filepath.Join(dir, "projects", "project")
+	child := filepath.Join(project, "session", "subagents")
+	if err := os.MkdirAll(child, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	for _, path := range []string{filepath.Join(project, "session.jsonl"), filepath.Join(child, "agent-worker.jsonl"), filepath.Join(child, "other.jsonl")} {
+		if err := os.WriteFile(path, claudeUsageLine("session", "request", true, 30), 0o600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := os.Symlink(filepath.Join(project, "session.jsonl"), filepath.Join(project, "copy.jsonl")); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(project, filepath.Join(dir, "projects", "linked")); err != nil {
+		t.Fatal(err)
+	}
+	files, err := ListClaudeCodeSessionFilesContext(ctx, dir)
+	if err != nil || len(files) != 2 {
+		t.Fatalf("discovery: %d, %v", len(files), err)
+	}
+	canceled, cancel := context.WithCancel(ctx)
+	cancel()
+	if _, err := ListClaudeCodeSessionFilesContext(canceled, dir); !errors.Is(err, context.Canceled) {
+		t.Fatalf("cancellation: %v", err)
+	}
+}
+
+func TestClaudeCodePartialConflictRetainsFirstPricingForValidCompletion(t *testing.T) {
+	ctx := context.Background()
+	factory := store.NewFactory(filepath.Join(t.TempDir(), "profiledeck.db"))
+	db, err := factory.Open(ctx, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	if _, err := db.Migrate(ctx); err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	project := filepath.Join(dir, "projects", "project")
+	if err := os.MkdirAll(project, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	path := filepath.Join(project, "session.jsonl")
+	partial := claudeUsageLine("session", "request", false, 1)
+	if err := os.WriteFile(path, partial, 0o600); err != nil {
+		t.Fatal(err)
+	}
+	integration := NewClaudeCodeIntegrationWithProvisioner(dir, claudeTestProvisioner{})
+	if _, err := integration.Sync(ctx, factory, SyncOptions{ProvisionMode: SyncProvisionProvider}); err != nil {
+		t.Fatal(err)
+	}
+	contradictory := bytes.Replace(partial, []byte(`"input_tokens":70`), []byte(`"input_tokens":71`), 1)
+	if err := os.WriteFile(path, append(append([]byte{}, partial...), contradictory...), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := integration.Sync(ctx, factory, SyncOptions{ProvisionMode: SyncExistingProvider}); err != nil {
+		t.Fatal(err)
+	}
+	summary, err := db.UsageSummary(ctx, "claude-code")
+	if err != nil || summary.TotalTokens != 0 || summary.ConflictingEventCount != 1 {
+		t.Fatalf("partial conflict: %+v, %v", summary, err)
+	}
+	integrity, err := db.InspectIntegrity(ctx, store.IntegrityCurrentBaseline)
+	if err != nil || len(integrity.Issues) != 0 {
+		t.Fatalf("retained snapshot integrity: %+v, %v", integrity, err)
+	}
+	catalog := pricing.Embedded()
+	catalog.CatalogVersion++
+	for i := range catalog.Entries {
+		if catalog.Entries[i].Model == "claude-opus-5-5" {
+			catalog.Entries[i].ShortContext.Output = "99"
+		}
+	}
+	content := append(append(append([]byte{}, partial...), contradictory...), claudeUsageLine("session", "request", true, 30)...)
+	if err := os.WriteFile(path, content, 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := integration.Sync(withPricingSnapshot(ctx, catalog), factory, SyncOptions{ProvisionMode: SyncExistingProvider}); err != nil {
+		t.Fatal(err)
+	}
+	summary, err = db.UsageSummary(ctx, "claude-code")
+	if err != nil || summary.TotalTokens != 130 || summary.EstimatedCostMicros != 964 {
+		t.Fatalf("pricing changed during conflict: %+v, %v", summary, err)
+	}
+}
diff --git a/internal/usage/codex_sync.go b/internal/usage/codex_sync.go
index bc848f8..f67fcf6 100644
--- a/internal/usage/codex_sync.go
+++ b/internal/usage/codex_sync.go
@@ -601,6 +601,8 @@ func usageEventsToFactParams(sourceID int64, events []Event) []store.CreateUsage
 	facts := make([]store.CreateUsageFactParams, 0, len(events))
 	for _, event := range events {
 		facts = append(facts, store.CreateUsageFactParams{
+			TokenStatus: event.TokenStatus, CacheWrite5mTokens: event.CacheWrite5mTokens, CacheWrite1hTokens: event.CacheWrite1hTokens,
+			PricingEligible: event.PricingEligible, PriceSnapshot: event.PriceSnapshot,
 			EventKey:                 event.EventKey,
 			SourceID:                 sourceID,
 			SessionKey:               event.SessionID,
diff --git a/internal/usage/codex_test.go b/internal/usage/codex_test.go
index 6bce292..adb171b 100644
--- a/internal/usage/codex_test.go
+++ b/internal/usage/codex_test.go
@@ -131,7 +131,7 @@ func TestParseCodexSessionFilePricesMatchedCacheWriteAndLongContext(t *testing.T
 	}
 	event := parsed.Events[0]
 	if event.CostStatus != CostStatusEstimated || event.EstimatedCostMicros == nil || *event.EstimatedCostMicros != 5_975_000 ||
-		event.CacheWriteInputTokens == nil || *event.CacheWriteInputTokens != 25_000 || event.PricingCatalogVersion == nil || *event.PricingCatalogVersion != 1 {
+		event.CacheWriteInputTokens == nil || *event.CacheWriteInputTokens != 25_000 || event.PricingCatalogVersion == nil || *event.PricingCatalogVersion != bundledPricingCatalog.CatalogVersion {
 		t.Fatalf("matched cache write and long context = %#v", event)
 	}
 }
diff --git a/internal/usage/incremental_reader.go b/internal/usage/incremental_reader.go
index cb09aa4..d0dc6e9 100644
--- a/internal/usage/incremental_reader.go
+++ b/internal/usage/incremental_reader.go
@@ -69,6 +69,7 @@ type checkpointParseResult struct {
 	BoundaryDigest        store.UsageKey
 	CheckpointEventDigest store.UsageKey
 	ParserStateJSON       string
+	ClaudeInvalidReasons  map[string]int64
 }
 
 func parseCodexCheckpointFile(
@@ -256,6 +257,103 @@ func parseGrokBuildCheckpointFile(
 	return result, nil
 }
 
+func parseClaudeCodeCheckpointFile(
+	ctx context.Context,
+	file SourceFile,
+	start int64,
+	eventDigest store.UsageKey,
+	expectedBoundary store.UsageKey,
+	fileSystem usageFileSystem,
+	observer UsageSyncObserver,
+	parserRevision int64,
+) (checkpointParseResult, error) {
+	if fileSystem == nil {
+		fileSystem = osUsageFileSystem{}
+	}
+	handle, err := openStableUsageFile(file, fileSystem, observer)
+	if err != nil {
+		return checkpointParseResult{}, err
+	}
+	defer handle.Close()
+	if start < 0 || start > file.SizeBytes {
+		return checkpointParseResult{}, errors.New("usage checkpoint is outside the Claude Code session file")
+	}
+	boundary, err := readUsageBoundaryWindow(handle, start, observer)
+	if err != nil {
+		return checkpointParseResult{}, err
+	}
+	if start > 0 {
+		if boundary.digest() != expectedBoundary {
+			return checkpointParseResult{}, errUsageBoundaryChanged
+		}
+	}
+	if eventDigest.IsZero() {
+		eventDigest = initialCheckpointEventDigest("claude-code")
+	}
+	result := checkpointParseResult{
+		ProcessedBytes:        start,
+		CheckpointEventDigest: eventDigest,
+		ClaudeInvalidReasons:  make(map[string]int64),
+	}
+	section := io.NewSectionReader(observedReaderAt{reader: handle, observer: observer}, start, file.SizeBytes-start)
+	reader := bufio.NewReaderSize(section, 64*1024)
+	for {
+		if err := ctx.Err(); err != nil {
+			return checkpointParseResult{}, err
+		}
+		rawLine, boundarySuffix, tooLong, terminated, consumed, err := readCheckpointLine(
+			ctx,
+			reader,
+			maxClaudeCodeSessionLineBytes,
+		)
+		if errors.Is(err, io.EOF) {
+			break
+		}
+		if err != nil {
+			return checkpointParseResult{}, err
+		}
+		if tooLong {
+			if !terminated {
+				break
+			}
+			result.InvalidLines++
+			result.ClaudeInvalidReasons[store.ClaudeCodeRecordTooLarge]++
+			result.ProcessedBytes += consumed
+			boundary.appendSuffix(boundarySuffix, consumed)
+			continue
+		}
+		line := bytes.TrimSpace(rawLine)
+		if len(line) == 0 {
+			result.ProcessedBytes += consumed
+			boundary.appendSuffix(boundarySuffix, consumed)
+			continue
+		}
+		event, invalidReason, unsupported, parseErr := parseClaudeCodeSessionObservationForRevision(line, parserRevision)
+		if parseErr != nil && !terminated {
+			break
+		}
+		if invalidReason != "" {
+			result.InvalidLines++
+			result.ClaudeInvalidReasons[invalidReason]++
+		}
+		if event != nil {
+			result.Events = append(result.Events, *event)
+			result.CheckpointEventDigest = advanceCheckpointEventDigest("claude-code", result.CheckpointEventDigest, *event)
+		}
+
+		if unsupported {
+			result.UnsupportedLines++
+		}
+		result.ProcessedBytes += consumed
+		boundary.appendSuffix(boundarySuffix, consumed)
+	}
+	result.BoundaryDigest = boundary.digest()
+	if err := verifyStableUsageFile(file, handle, fileSystem); err != nil {
+		return checkpointParseResult{}, err
+	}
+	return result, nil
+}
+
 var errUsageBoundaryChanged = errors.New("usage file changed before the saved checkpoint")
 
 func openStableUsageFile(
@@ -440,6 +538,19 @@ func advanceCheckpointEventDigest(
 		binary.BigEndian.PutUint64(encoded[:], uint64(value))
 		_, _ = hash.Write(encoded[:])
 	}
+	if providerID == "claude-code" {
+		projection, _ := json.Marshal(struct {
+			Model    string
+			Session  string
+			Time     int64
+			Status   store.UsageTokenStatus
+			Write    *int64
+			Five     *int64
+			Hour     *int64
+			Eligible bool
+		}{event.Model, event.SessionID, event.OccurredAtUnixMS, event.TokenStatus, event.CacheCreationInputTokens, event.CacheWrite5mTokens, event.CacheWrite1hTokens, event.PricingEligible})
+		_, _ = hash.Write(projection)
+	}
 	var digest store.UsageKey
 	copy(digest[:], hash.Sum(nil))
 	return digest
diff --git a/internal/usage/report_service.go b/internal/usage/report_service.go
index 3be304f..0e62c43 100644
--- a/internal/usage/report_service.go
+++ b/internal/usage/report_service.go
@@ -31,6 +31,13 @@ type UsageResolvedRange struct {
 }
 
 type UsageAggregateSummary struct {
+	MissingOutputCostEventCount   int64   `json:"missing_output_cost_event_count"`
+	MissingCacheTTLEventCount     int64   `json:"missing_cache_ttl_event_count"`
+	MissingCacheRateEventCount    int64   `json:"missing_cache_rate_event_count"`
+	TokenTotalStatus              string  `json:"token_total_status"`
+	OutputTokensStatus            string  `json:"output_tokens_status"`
+	IncompleteEventCount          int64   `json:"incomplete_event_count"`
+	ConflictingEventCount         int64   `json:"conflicting_event_count"`
 	EventCount                    int64   `json:"event_count"`
 	SessionCount                  int64   `json:"session_count"`
 	FreshInputTokens              int64   `json:"fresh_input_tokens"`
@@ -68,10 +75,11 @@ type UsageModelSummary struct {
 }
 
 type UsageImportSummary struct {
-	TrackedFiles       int64 `json:"tracked_files"`
-	LastSyncedAtUnixMS int64 `json:"last_synced_at_unix_ms"`
-	InvalidLines       int64 `json:"invalid_lines"`
-	UnsupportedLines   int64 `json:"unsupported_lines"`
+	InvalidReasons     map[string]int64 `json:"invalid_reasons"`
+	TrackedFiles       int64            `json:"tracked_files"`
+	LastSyncedAtUnixMS int64            `json:"last_synced_at_unix_ms"`
+	InvalidLines       int64            `json:"invalid_lines"`
+	UnsupportedLines   int64            `json:"unsupported_lines"`
 }
 
 type UsagePricingInfo struct {
@@ -184,6 +192,7 @@ func (service *Service) usageReportAt(ctx context.Context, req UsageReportReques
 		},
 		Summary: usageAggregateSummary(snapshot.Summary),
 		Import: UsageImportSummary{
+			InvalidReasons:     snapshot.ImportSummary.InvalidReasons,
 			TrackedFiles:       snapshot.ImportSummary.TrackedFiles,
 			LastSyncedAtUnixMS: snapshot.ImportSummary.LastSyncedAtUnixMS,
 			InvalidLines:       snapshot.ImportSummary.InvalidLines,
@@ -227,7 +236,13 @@ func usageAggregateSummary(aggregate store.UsageAggregate) UsageAggregateSummary
 		aggregate.PartialReportedCostEventCount,
 		aggregate.UnknownReportedCostEvents,
 	)
+	totalStatus, outputStatus := usageTokenStatuses(aggregate.EventCount, aggregate.IncompleteEventCount, aggregate.ConflictingEventCount)
 	return UsageAggregateSummary{
+		MissingOutputCostEventCount: aggregate.MissingOutputCostEventCount,
+		MissingCacheTTLEventCount:   aggregate.MissingCacheTTLEventCount,
+		MissingCacheRateEventCount:  aggregate.MissingCacheRateEventCount,
+		TokenTotalStatus:            totalStatus, OutputTokensStatus: outputStatus,
+		IncompleteEventCount: aggregate.IncompleteEventCount, ConflictingEventCount: aggregate.ConflictingEventCount,
 		EventCount:                    aggregate.EventCount,
 		SessionCount:                  aggregate.SessionCount,
 		FreshInputTokens:              aggregate.FreshInputTokens,
@@ -276,3 +291,18 @@ func ratio(numerator, denominator int64) float64 {
 	}
 	return value
 }
+
+func usageTokenStatuses(events, incomplete, conflicts int64) (string, string) {
+	total, output := "complete", "complete"
+	if incomplete+conflicts > 0 {
+		total = "partial"
+		output = "partial"
+	}
+	if events > 0 && events == conflicts {
+		total = "unknown"
+	}
+	if events > 0 && events == conflicts+incomplete {
+		output = "unknown"
+	}
+	return total, output
+}
diff --git a/internal/usage/service.go b/internal/usage/service.go
index e9bd333..7755628 100644
--- a/internal/usage/service.go
+++ b/internal/usage/service.go
@@ -39,6 +39,7 @@ type UsageSyncRequest struct {
 }
 
 type UsageSyncResult struct {
+	UpdatedEvents          int64              `json:"updated_events"`
 	ProviderID             string             `json:"provider_id"`
 	Source                 string             `json:"source"`
 	ScannedFiles           int64              `json:"scanned_files"`
@@ -55,6 +56,10 @@ type UsageSummaryRequest struct {
 }
 
 type UsageSummaryResult struct {
+	TokenTotalStatus              string   `json:"token_total_status"`
+	OutputTokensStatus            string   `json:"output_tokens_status"`
+	IncompleteEventCount          int64    `json:"incomplete_event_count"`
+	ConflictingEventCount         int64    `json:"conflicting_event_count"`
 	ProviderID                    string   `json:"provider_id"`
 	Source                        string   `json:"source"`
 	Sources                       []string `json:"sources"`
@@ -64,6 +69,7 @@ type UsageSummaryResult struct {
 	OutputTokens                  int64    `json:"output_tokens"`
 	TotalTokens                   int64    `json:"total_tokens"`
 	EstimatedCostUSD              *string  `json:"estimated_cost_usd"`
+	KnownEstimatedCostUSD         string   `json:"known_estimated_cost_usd"`
 	CostStatus                    string   `json:"cost_status"`
 	UnknownCostEventCount         int64    `json:"unknown_cost_event_count"`
 	EstimatedCostEventCount       int64    `json:"estimated_cost_event_count"`
@@ -282,7 +288,9 @@ func (service *Service) Summary(ctx context.Context, req UsageSummaryRequest) (U
 	if err != nil {
 		return UsageSummaryResult{}, apperror.Wrap(apperror.StoreStatusFailed, "failed to read usage summary", err)
 	}
+	totalStatus, outputStatus := usageTokenStatuses(summary.EventCount, summary.IncompleteEventCount, summary.ConflictingEventCount)
 	result := UsageSummaryResult{
+		TokenTotalStatus: totalStatus, OutputTokensStatus: outputStatus, IncompleteEventCount: summary.IncompleteEventCount, ConflictingEventCount: summary.ConflictingEventCount,
 		ProviderID:                    providerID,
 		Source:                        summarySource(summary.Sources),
 		Sources:                       summary.Sources,
@@ -292,6 +300,7 @@ func (service *Service) Summary(ctx context.Context, req UsageSummaryRequest) (U
 		OutputTokens:                  summary.OutputTokens,
 		TotalTokens:                   summary.TotalTokens,
 		CostStatus:                    CostStatusEstimated.String(),
+		KnownEstimatedCostUSD:         USDStringFromMicros(summary.EstimatedCostMicros),
 		UnknownCostEventCount:         summary.UnknownCostEvents + summary.PartialCostEvents,
 		EstimatedCostEventCount:       summary.EstimatedCostEventCount,
 		ReportedCostStatus:            ReportedCostStatusUnknown.String(),
diff --git a/internal/usage/usage.go b/internal/usage/usage.go
index 427be51..d2854d6 100644
--- a/internal/usage/usage.go
+++ b/internal/usage/usage.go
@@ -46,6 +46,11 @@ type TokenCounts struct {
 }
 
 type Event struct {
+	TokenStatus              store.UsageTokenStatus
+	CacheWrite5mTokens       *int64
+	CacheWrite1hTokens       *int64
+	PricingEligible          bool
+	PriceSnapshot            *store.UsagePriceSnapshot
 	EventKey                 store.UsageKey
 	SessionID                string
 	Model                    string
diff --git a/pricing/catalog.json b/pricing/catalog.json
index 668637f..9a2e66f 100644
--- a/pricing/catalog.json
+++ b/pricing/catalog.json
@@ -1,6 +1,6 @@
 {
-  "schema_version": 1,
-  "catalog_version": 1,
+  "schema_version": 2,
+  "catalog_version": 2,
   "entries": [
     {
       "provider": "codex",
@@ -519,19 +519,80 @@
         }
       }
     },
+    {
+      "provider": "claude-code",
+      "model": "claude-opus-4-7",
+      "basis": "anthropic-standard-api",
+      "effective_from": "2026-04-16",
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_at": "2026-09-28",
+      "short_context": {
+        "input": "5",
+        "cached_input": "0.5",
+        "cache_write": "6.25",
+        "cache_write_1h": "10",
+        "output": "25"
+      }
+    },
+    {
+      "provider": "claude-code",
+      "model": "claude-opus-5",
+      "basis": "anthropic-standard-api",
+      "effective_from": "2026-07-24",
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_at": "2026-09-28",
+      "short_context": {
+        "input": "5",
+        "cached_input": "0.5",
+        "cache_write": "6.25",
+        "cache_write_1h": "10",
+        "output": "25"
+      }
+    },
     {
       "provider": "claude-code",
       "model": "claude-opus-5-5",
       "basis": "anthropic-standard-api",
       "effective_from": "2026-09-22",
-      "source_url": "https://platform.claude.com/docs/en/models/opus-5-5/overview",
-      "verified_at": "2026-09-23",
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_at": "2026-09-28",
       "short_context": {
         "input": "4",
-        "cached_input": ".2",
+        "cached_input": "0.2",
         "cache_write": "5",
+        "cache_write_1h": "8",
         "output": "20"
       }
+    },
+    {
+      "provider": "claude-code",
+      "model": "claude-sonnet-5",
+      "basis": "anthropic-standard-api",
+      "effective_from": "2026-06-30",
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_at": "2026-09-28",
+      "short_context": {
+        "input": "2",
+        "cached_input": "0.2",
+        "cache_write": "2.5",
+        "cache_write_1h": "4",
+        "output": "10"
+      }
+    },
+    {
+      "provider": "claude-code",
+      "model": "claude-haiku-4-5-20251001",
+      "basis": "anthropic-standard-api",
+      "effective_from": "2025-10-15",
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_at": "2026-09-28",
+      "short_context": {
+        "input": "1",
+        "cached_input": "0.1",
+        "cache_write": "1.25",
+        "cache_write_1h": "2",
+        "output": "5"
+      }
     }
   ]
 }