diff --git a/apps/desktop-tauri/src-tauri/src/auto_refresh.rs b/apps/desktop-tauri/src-tauri/src/auto_refresh.rs
index 6825f4170d..75128cb00d 100644
--- a/apps/desktop-tauri/src-tauri/src/auto_refresh.rs
+++ b/apps/desktop-tauri/src-tauri/src/auto_refresh.rs
@@ -218,7 +218,7 @@ fn local_usage_provider_ids(settings: &Settings) -> Vec<String> {
         .get_enabled_provider_ids()
         .into_iter()
         .map(|provider| provider.cli_name().to_string())
-        .filter(|provider_id| matches!(provider_id.as_str(), "codex" | "claude" | "muse"))
+        .filter(|provider_id| matches!(provider_id.as_str(), "codex" | "claude" | "pi" | "muse"))
         .collect()
 }
 
diff --git a/apps/desktop-tauri/src-tauri/src/commands/chart.rs b/apps/desktop-tauri/src-tauri/src/commands/chart.rs
index 5e66b2d003..4561dd9129 100644
--- a/apps/desktop-tauri/src-tauri/src/commands/chart.rs
+++ b/apps/desktop-tauri/src-tauri/src/commands/chart.rs
@@ -644,6 +644,7 @@ fn scan_local_cost(
     match provider_id {
         "codex" => Some(scanner.scan_codex_with_cancel(cancel)),
         "claude" => Some(scanner.scan_claude_with_cancel(cancel)),
+        "pi" => Some(scanner.scan_pi_with_cancel(cancel)),
         "opencodego" => Some(scanner.scan_opencodego_with_cancel(cancel)),
         _ => None,
     }
diff --git a/apps/desktop-tauri/src-tauri/src/commands/spend_contract.rs b/apps/desktop-tauri/src-tauri/src/commands/spend_contract.rs
index a3e3637f12..4403ba7ad0 100644
--- a/apps/desktop-tauri/src-tauri/src/commands/spend_contract.rs
+++ b/apps/desktop-tauri/src-tauri/src/commands/spend_contract.rs
@@ -11,7 +11,7 @@ pub async fn get_spend_contract(
     include_open_codex: Option<bool>,
 ) -> Result<SpendContract, String> {
     let provider = provider_id.trim().to_ascii_lowercase();
-    if !matches!(provider.as_str(), "codex" | "claude" | "opencodego") {
+    if !matches!(provider.as_str(), "codex" | "claude" | "pi" | "opencodego") {
         return Err(format!(
             "Spend contract is unavailable for provider: {provider}"
         ));
@@ -24,6 +24,7 @@ pub async fn get_spend_contract(
         let summary = match provider.as_str() {
             "codex" => scanner.scan_codex(),
             "claude" => scanner.scan_claude(),
+            "pi" => scanner.scan_pi(),
             "opencodego" => scanner.scan_opencodego_with_cancel(None),
             _ => unreachable!(),
         };
diff --git a/apps/desktop-tauri/src-tauri/src/commands/usage_spend.rs b/apps/desktop-tauri/src-tauri/src/commands/usage_spend.rs
index f55ae71cd2..01f562e111 100644
--- a/apps/desktop-tauri/src-tauri/src/commands/usage_spend.rs
+++ b/apps/desktop-tauri/src-tauri/src/commands/usage_spend.rs
@@ -363,6 +363,9 @@ fn build_usage_spend_summary(
 ) -> UsageSpendSummary {
     let include_opencodex = settings.open_codex_usage_logs_enabled;
     let hide_native = settings.hide_native_codex_cost_when_open_codex_present;
+    let pi_selected = settings.enabled_providers.iter().any(|id| id == "pi")
+        || cached.iter().any(|snapshot| snapshot.provider_id == "pi");
+    let include_pi_in_native = !pi_selected;
 
     // Upstream 0.55.0 #3105: independent provider baselines load in parallel.
     // Keep each provider's 7d/30d scans serial so they can safely share that
@@ -372,29 +375,43 @@ fn build_usage_spend_summary(
     } else {
         codexbar::core::CostScanOptions::default()
     };
-    let ((codex_7_summary, codex_30_summary), (claude_7_summary, claude_30_summary)) =
-        std::thread::scope(|scope| {
-            let codex = scope.spawn(move || {
-                (
-                    CostScanner::new(7)
-                        .with_options(codex_scan_options)
-                        .scan_codex(),
-                    CostScanner::new(30)
-                        .with_options(codex_scan_options)
-                        .scan_codex(),
-                )
-            });
-            let claude = scope.spawn(|| {
-                (
-                    CostScanner::new(7).scan_claude(),
-                    CostScanner::new(30).scan_claude(),
-                )
-            });
+    let mut codex_scan_options = codex_scan_options;
+    codex_scan_options.include_pi_sessions = include_pi_in_native;
+    let (
+        (codex_7_summary, codex_30_summary),
+        (claude_7_summary, claude_30_summary),
+        (pi_7_summary, pi_30_summary),
+    ) = std::thread::scope(|scope| {
+        let codex = scope.spawn(move || {
+            (
+                CostScanner::new(7)
+                    .with_options(codex_scan_options)
+                    .scan_codex(),
+                CostScanner::new(30)
+                    .with_options(codex_scan_options)
+                    .scan_codex(),
+            )
+        });
+        let claude = scope.spawn(|| {
+            (
+                CostScanner::new(7)
+                    .scan_claude_with_cancel_and_pi_sessions(None, include_pi_in_native),
+                CostScanner::new(30)
+                    .scan_claude_with_cancel_and_pi_sessions(None, include_pi_in_native),
+            )
+        });
+        let pi = scope.spawn(|| {
             (
-                codex.join().expect("Codex spend scan worker panicked"),
-                claude.join().expect("Claude spend scan worker panicked"),
+                CostScanner::new(7).scan_pi(),
+                CostScanner::new(30).scan_pi(),
             )
         });
+        (
+            codex.join().expect("Codex spend scan worker panicked"),
+            claude.join().expect("Claude spend scan worker panicked"),
+            pi.join().expect("Pi spend scan worker panicked"),
+        )
+    });
 
     let codex_stale = !codex_30_summary.history_coverage_established;
     let codex_stale_updated_at = codex_stale
@@ -421,6 +438,22 @@ fn build_usage_spend_summary(
         settings.hide_personal_info,
         codex_30_summary.clone(),
     );
+    let pi_7_contract = build_local_spend_contract_from_summary(
+        "pi",
+        7,
+        false,
+        false,
+        settings.hide_personal_info,
+        pi_7_summary.clone(),
+    );
+    let pi_30_contract = build_local_spend_contract_from_summary(
+        "pi",
+        30,
+        false,
+        false,
+        settings.hide_personal_info,
+        pi_30_summary.clone(),
+    );
 
     let mut provider_ids: BTreeSet<String> = settings.enabled_providers.iter().cloned().collect();
     provider_ids.extend(cached.iter().map(|snapshot| snapshot.provider_id.clone()));
@@ -494,6 +527,15 @@ fn build_usage_spend_summary(
                 refreshing: false,
                 stale_updated_at: None,
             },
+            "pi" => SpendValues {
+                seven_day: pi_7_contract.known_cost_usd,
+                thirty_day: pi_30_contract.known_cost_usd,
+                seven_day_tokens: total_token_mix(&pi_7_contract.token_mix),
+                thirty_day_tokens: total_token_mix(&pi_30_contract.token_mix),
+                source: "local Pi/OMP history".to_string(),
+                refreshing: !pi_30_summary.history_coverage_established,
+                stale_updated_at: None,
+            },
             "opencodego" | "kimi" | "deepseek" if include_opencodex => {
                 let seven = build_local_spend_contract(&provider_id, 7, true);
                 let thirty = build_local_spend_contract(&provider_id, 30, true);
@@ -585,8 +627,11 @@ fn build_usage_spend_summary(
             thirty_day_tokens: spend.thirty_day_tokens,
             currency,
             source: spend.source,
-            included_in_overview: settings.enabled_providers.contains(&provider_id)
-                || cached_snapshot.is_some(),
+            included_in_overview: include_in_shared_overview(
+                &provider_id,
+                settings.enabled_providers.contains(&provider_id),
+                cached_snapshot.is_some(),
+            ),
             daily,
             refreshing: spend.refreshing,
             stale_updated_at: spend.stale_updated_at,
@@ -623,6 +668,13 @@ fn build_usage_spend_summary(
     }
 }
 
+/// Pi is an alternate local-history view over rows that may already be
+/// projected into Codex or Claude. Keep it out of the shared denominator so
+/// enabling Pi cannot double-count the same physical usage.
+fn include_in_shared_overview(provider_id: &str, enabled: bool, cached: bool) -> bool {
+    provider_id != "pi" && (enabled || cached)
+}
+
 fn last_included_reporting_day(contract: &SpendContract) -> String {
     contract
         .daily
@@ -774,4 +826,12 @@ mod cache_key_tests {
         let private = usage_spend_cache_key_with_privacy(&[], 30, false, false, true);
         assert_ne!(public, private);
     }
+
+    #[test]
+    fn pi_history_is_an_alternate_view_not_a_shared_overview_source() {
+        assert!(!include_in_shared_overview("pi", true, true));
+        assert!(include_in_shared_overview("codex", true, false));
+        assert!(include_in_shared_overview("claude", false, true));
+        assert!(!include_in_shared_overview("codex", false, false));
+    }
 }
diff --git a/apps/desktop-tauri/src/components/providers/providerIcons.ts b/apps/desktop-tauri/src/components/providers/providerIcons.ts
index a2cf5dda8a..ccfa304078 100644
--- a/apps/desktop-tauri/src/components/providers/providerIcons.ts
+++ b/apps/desktop-tauri/src/components/providers/providerIcons.ts
@@ -166,6 +166,7 @@ export const PROVIDER_ICON_REGISTRY: Record<string, ProviderIcon> = {
   antigravity: { id: "antigravity", brandColor: "#60ba7e", fallbackLetter: "◉", svgPath: RAW.antigravity },
   augment:     { id: "augment",     brandColor: "#6366f1", fallbackLetter: "A", svgPath: RAW.augment },
   claude:      { id: "claude",      brandColor: "#cc7c5e", fallbackLetter: "◈", svgPath: RAW.claude },
+  pi:          { id: "pi",          brandColor: "#7c3aed", fallbackLetter: "P" },
   codebuff:    { id: "codebuff",    brandColor: "#44ff00", fallbackLetter: "B", svgPath: RAW.codebuff },
   coderabbit:  { id: "coderabbit",  brandColor: "#ff5c35", fallbackLetter: "C", svgPath: RAW.coderabbit },
   codex:       { id: "codex",       brandColor: "#49a3b0", fallbackLetter: "◆", svgPath: RAW.codex },
diff --git a/apps/desktop-tauri/src/lib/providerCharts.test.ts b/apps/desktop-tauri/src/lib/providerCharts.test.ts
index bf8d1179a4..0f3c27a6be 100644
--- a/apps/desktop-tauri/src/lib/providerCharts.test.ts
+++ b/apps/desktop-tauri/src/lib/providerCharts.test.ts
@@ -7,6 +7,7 @@ describe("providerSupportsChartData", () => {
     expect(providerSupportsChartData("claude")).toBe(true);
     expect(providerSupportsChartData("openai")).toBe(true);
     expect(providerSupportsChartData("muse")).toBe(true);
+    expect(providerSupportsChartData("pi")).toBe(true);
     expect(providerSupportsChartData("OpenAI")).toBe(true);
 
     expect(providerSupportsChartData("copilot")).toBe(false);
diff --git a/apps/desktop-tauri/src/lib/providerCharts.ts b/apps/desktop-tauri/src/lib/providerCharts.ts
index f230f80090..6a4bec3586 100644
--- a/apps/desktop-tauri/src/lib/providerCharts.ts
+++ b/apps/desktop-tauri/src/lib/providerCharts.ts
@@ -1,4 +1,4 @@
-const PROVIDER_CHART_DATA_IDS = new Set(["claude", "codex", "muse", "openai"]);
+const PROVIDER_CHART_DATA_IDS = new Set(["claude", "codex", "muse", "openai", "pi"]);
 
 export function providerSupportsChartData(providerId: string): boolean {
   return PROVIDER_CHART_DATA_IDS.has(providerId.toLowerCase());
diff --git a/apps/desktop-tauri/src/surfaces/settings/providers/ProvidersSidebar.test.tsx b/apps/desktop-tauri/src/surfaces/settings/providers/ProvidersSidebar.test.tsx
index 8b947a7dc0..e85aa379ce 100644
--- a/apps/desktop-tauri/src/surfaces/settings/providers/ProvidersSidebar.test.tsx
+++ b/apps/desktop-tauri/src/surfaces/settings/providers/ProvidersSidebar.test.tsx
@@ -133,7 +133,7 @@ describe("ProvidersSidebar", () => {
         container.querySelectorAll(".providers-sidebar__name"),
         (node) => node.textContent,
       );
-      expect(names.slice(0, 3)).toEqual(["Claude", "Codex", "Cursor"]);
+      expect(names.slice(0, 3)).toEqual(["Claude", "Codex", "Pi"]);
     });
   });
 
diff --git a/apps/desktop-tauri/src/surfaces/settings/providers/sections/charts/ChartsSection.tsx b/apps/desktop-tauri/src/surfaces/settings/providers/sections/charts/ChartsSection.tsx
index 86bcb183eb..8257e3069c 100644
--- a/apps/desktop-tauri/src/surfaces/settings/providers/sections/charts/ChartsSection.tsx
+++ b/apps/desktop-tauri/src/surfaces/settings/providers/sections/charts/ChartsSection.tsx
@@ -89,7 +89,9 @@ export function ChartsSection({ providerId, accountEmail, accentColor, t }: Prop
 
   // Upstream 0.50.0 #2930: Codex defaults to exact local token totals.
   const defaultTab: TabKey =
-    (providerId === "codex" || providerId === "muse") && hasTokens ? "tokens" : available[0];
+    (providerId === "codex" || providerId === "muse" || providerId === "pi") && hasTokens
+      ? "tokens"
+      : available[0];
   const current: TabKey =
     active && available.includes(active) ? active : defaultTab;
   const emptyMsg = t("DetailChartEmpty");
diff --git a/apps/desktop-tauri/src/test/providerCatalog.ts b/apps/desktop-tauri/src/test/providerCatalog.ts
index 6eac860900..c8ab2daa5d 100644
--- a/apps/desktop-tauri/src/test/providerCatalog.ts
+++ b/apps/desktop-tauri/src/test/providerCatalog.ts
@@ -1,6 +1,7 @@
 export const TEST_PROVIDER_CATALOG: Array<[string, string]> = [
   ["codex", "Codex"],
   ["claude", "Claude"],
+  ["pi", "Pi"],
   ["cursor", "Cursor"],
   ["factory", "Factory"],
   ["gemini", "Gemini"],
diff --git a/rust/src/cli/cost.rs b/rust/src/cli/cost.rs
index fe12351104..8e9be16dc2 100755
--- a/rust/src/cli/cost.rs
+++ b/rust/src/cli/cost.rs
@@ -16,7 +16,7 @@ use crate::spend_contract::build_local_spend_contract_from_summary;
 /// Arguments for the cost command
 #[derive(Args, Debug, Default)]
 pub struct CostArgs {
-    /// Provider to query (codex, claude, muse, antigravity, cursor, gemini, copilot, all, both)
+    /// Provider to query (codex, claude, pi, muse, antigravity, cursor, gemini, copilot, all, both)
     #[arg(short, long)]
     pub provider: Option<String>,
 
@@ -109,7 +109,12 @@ pub async fn run(args: CostArgs) -> anyhow::Result<()> {
     }
 
     let mut scan_options = CostScanOptions::app_driven();
-    scan_options.include_pi_sessions = !args.provider_native_only;
+    let requested_providers = providers.as_list();
+    let pi_selected = requested_providers.contains(&ProviderId::Pi);
+    // When Pi is selected alongside native providers, the standalone Pi row
+    // owns its mirrored Codex/Claude events. A single native-provider request
+    // keeps the historical inclusive behavior unless explicitly narrowed.
+    scan_options.include_pi_sessions = !args.provider_native_only && !pi_selected;
     let scanner = CostScanner::new(args.days).with_options(scan_options);
 
     tracing::debug!(
@@ -135,7 +140,21 @@ pub async fn run(args: CostArgs) -> anyhow::Result<()> {
                 });
             }
             ProviderId::Claude => {
-                let summary = scanner.scan_claude();
+                let summary = if pi_selected || args.provider_native_only {
+                    scanner.scan_claude_with_cancel_and_pi_sessions(None, false)
+                } else {
+                    scanner.scan_claude()
+                };
+                results.push(CostResult {
+                    provider: provider.cli_name().to_string(),
+                    display_name: provider.display_name().to_string(),
+                    summary,
+                    supported: true,
+                    token_history: None,
+                });
+            }
+            ProviderId::Pi => {
+                let summary = scanner.scan_pi();
                 results.push(CostResult {
                     provider: provider.cli_name().to_string(),
                     display_name: provider.display_name().to_string(),
@@ -450,7 +469,7 @@ fn build_json_payloads(results: &[CostResult], days: u32) -> Vec<serde_json::Val
                     "error": "Local cost scanning not available for this provider"
                 })
             } else {
-                let spend_contract = matches!(r.provider.as_str(), "codex" | "claude" | "opencodego")
+                let spend_contract = matches!(r.provider.as_str(), "codex" | "claude" | "pi" | "opencodego")
                     .then(|| build_local_spend_contract_from_summary(
                         &r.provider,
                         days.clamp(1, 365),
@@ -466,8 +485,8 @@ fn build_json_payloads(results: &[CostResult], days: u32) -> Vec<serde_json::Val
                     "cost": {"total_usd": r.summary.total_cost_usd, "currency": "USD"},
                     "tokens": {"input": r.summary.input_tokens, "output": r.summary.output_tokens, "cached": r.summary.cached_tokens},
                     "sessions_count": r.summary.sessions_count,
-                    "historyCoverageIsEstablished": if r.provider == "codex" { serde_json::Value::Bool(r.summary.history_coverage_established) } else { serde_json::Value::Null },
-                    "knownZero": if r.provider == "codex" { serde_json::Value::Bool(r.summary.known_zero) } else { serde_json::Value::Null },
+                    "historyCoverageIsEstablished": if matches!(r.provider.as_str(), "codex" | "pi") { serde_json::Value::Bool(r.summary.history_coverage_established) } else { serde_json::Value::Null },
+                    "knownZero": if matches!(r.provider.as_str(), "codex" | "pi") { serde_json::Value::Bool(r.summary.known_zero) } else { serde_json::Value::Null },
                     "modelPricingCompleteness": match &r.summary.model_pricing_completeness {
                         crate::cost_scanner::ModelPricingCompleteness::Complete => serde_json::Value::String("complete".to_string()),
                         crate::cost_scanner::ModelPricingCompleteness::Partial { unpriced_models } => serde_json::json!({"partial": {"unpriced_models": unpriced_models}}),
diff --git a/rust/src/cli/serve/dashboard/source.rs b/rust/src/cli/serve/dashboard/source.rs
index 76dc1dd162..8d28758df4 100644
--- a/rust/src/cli/serve/dashboard/source.rs
+++ b/rust/src/cli/serve/dashboard/source.rs
@@ -16,6 +16,7 @@ use chrono::{Local, Utc};
 use crate::core::{CostScanOptions, FetchContext, ProviderId, SourceMode, instantiate_provider};
 use crate::cost_scanner::{self, CostScanner};
 use crate::settings::Settings;
+use crate::spend_contract::build_local_spend_contract_from_summary;
 
 use crate::cli::serve::collection::{
     AccountFetchEnvelope, ClaudeAccountsInput, ProviderFetchEnvelope, RawCostPayload,
@@ -111,7 +112,7 @@ impl SnapshotProducer {
         let providers: Vec<ProviderFetchEnvelope> =
             indexed.into_iter().map(|(_, envelope)| envelope).collect();
 
-        let costs = collect_costs().await;
+        let costs = collect_costs(provider_ids.contains(&ProviderId::Pi)).await;
         let claude_accounts =
             collect_claude_accounts(provider_ids.contains(&ProviderId::Claude)).await;
 
@@ -205,13 +206,18 @@ async fn bounded_fetch(
     }
 }
 
-/// Local cost data for the two scanned providers, computed off the async
+/// Local cost data for the scanned providers, computed off the async
 /// runtime so a large corpus cannot stall dashboard builds.
-async fn collect_costs() -> HashMap<String, RawCostPayload> {
-    let result = tokio::task::spawn_blocking(|| {
-        let scanner = CostScanner::new(30).with_options(CostScanOptions::app_driven());
+async fn collect_costs(pi_selected: bool) -> HashMap<String, RawCostPayload> {
+    let result = tokio::task::spawn_blocking(move || {
+        let mut scan_options = CostScanOptions::app_driven();
+        scan_options.include_pi_sessions = !pi_selected;
+        let scanner = CostScanner::new(30).with_options(scan_options);
         let codex = scanner.scan_codex_with_cancel(None);
-        let claude = scanner.scan_claude_with_cancel(None);
+        let claude = scanner.scan_claude_with_cancel_and_pi_sessions(None, !pi_selected);
+        let pi = scanner.scan_pi_with_cancel(None);
+        let pi_contract =
+            build_local_spend_contract_from_summary("pi", 30, false, false, false, pi);
         let today = Local::now().date_naive().format("%Y-%m-%d").to_string();
         let today_of = |provider: &str| {
             cost_scanner::get_daily_cost_history(provider, 30)
@@ -234,6 +240,13 @@ async fn collect_costs() -> HashMap<String, RawCostPayload> {
                 last_30_days_usd: Some(claude.total_cost_usd),
             },
         );
+        costs.insert(
+            "pi".to_string(),
+            RawCostPayload {
+                today_usd: today_of("pi"),
+                last_30_days_usd: pi_contract.known_cost_usd,
+            },
+        );
         costs
     })
     .await;
diff --git a/rust/src/cli/serve/data.rs b/rust/src/cli/serve/data.rs
index 37130eba8d..d1841db6bc 100644
--- a/rust/src/cli/serve/data.rs
+++ b/rust/src/cli/serve/data.rs
@@ -88,6 +88,7 @@ pub async fn cost_response(provider: Option<&str>) -> String {
         let (supported, summary) = match provider_id {
             ProviderId::Codex => (true, scanner.scan_codex()),
             ProviderId::Claude => (true, scanner.scan_claude()),
+            ProviderId::Pi => (true, scanner.scan_pi()),
             _ => (false, Default::default()),
         };
         if supported {
diff --git a/rust/src/cli/usage.rs b/rust/src/cli/usage.rs
index f33373b90c..2b1dfff0af 100755
--- a/rust/src/cli/usage.rs
+++ b/rust/src/cli/usage.rs
@@ -25,7 +25,7 @@ pub(super) enum UsageOutput {
     Toon(Vec<serde_json::Value>),
 }
 
-pub const PROVIDER_ARG_HELP: &str = "Provider to query (for example: codex, claude, gemini, antigravity/agy, nanogpt, deepseek, codebuff, windsurf, all, both)";
+pub const PROVIDER_ARG_HELP: &str = "Provider to query (for example: codex, claude, pi, gemini, antigravity/agy, nanogpt, deepseek, codebuff, windsurf, all, both)";
 
 /// Arguments for the usage command
 #[derive(Args, Debug, Default)]
diff --git a/rust/src/core/provider.rs b/rust/src/core/provider.rs
index feedadedcd..d6a38df551 100755
--- a/rust/src/core/provider.rs
+++ b/rust/src/core/provider.rs
@@ -14,6 +14,7 @@ use super::provider_state::ProviderStateKind;
 pub enum ProviderId {
     Codex,
     Claude,
+    Pi,
     Cursor,
     Factory,
     Gemini,
@@ -97,6 +98,7 @@ impl ProviderId {
         &[
             ProviderId::Codex,
             ProviderId::Claude,
+            ProviderId::Pi,
             ProviderId::Cursor,
             ProviderId::Factory,
             ProviderId::Gemini,
@@ -179,6 +181,7 @@ impl ProviderId {
         match self {
             ProviderId::Codex => "codex",
             ProviderId::Claude => "claude",
+            ProviderId::Pi => "pi",
             ProviderId::Cursor => "cursor",
             ProviderId::Factory => "factory",
             ProviderId::Gemini => "gemini",
@@ -261,6 +264,7 @@ impl ProviderId {
         match self {
             ProviderId::Codex => "Codex",
             ProviderId::Claude => "Claude",
+            ProviderId::Pi => "Pi",
             ProviderId::Cursor => "Cursor",
             ProviderId::Factory => "Factory",
             ProviderId::Gemini => "Gemini",
@@ -349,6 +353,7 @@ impl ProviderId {
             ProviderId::Cursor => Some("cursor.com"),
             ProviderId::Factory => Some("app.factory.ai"),
             ProviderId::Codex => Some("chatgpt.com"),
+            ProviderId::Pi => None,
             ProviderId::Gemini => Some("aistudio.google.com"),
             ProviderId::Kiro => Some("kiro.dev"),
             ProviderId::Kimi => Some("kimi.moonshot.cn"),
@@ -432,6 +437,7 @@ impl ProviderId {
         match name.to_lowercase().as_str() {
             "codex" | "openai" => Some(ProviderId::Codex),
             "claude" | "anthropic" => Some(ProviderId::Claude),
+            "pi" | "pi-mono" => Some(ProviderId::Pi),
             "cursor" => Some(ProviderId::Cursor),
             "factory" | "droid" => Some(ProviderId::Factory),
             "gemini" | "google" => Some(ProviderId::Gemini),
@@ -1001,6 +1007,7 @@ pub fn brand_color(id: ProviderId) -> &'static str {
     match id {
         ProviderId::Codex => "#49A3B0",
         ProviderId::Claude => "#CC7C5E",
+        ProviderId::Pi => "#7C3AED",
         ProviderId::Cursor => "#00BFA5",
         ProviderId::Factory => "#FF6B35",
         ProviderId::Gemini => "#AB87EA",
@@ -1089,9 +1096,10 @@ mod tests {
     #[test]
     fn test_provider_id_all() {
         let all = ProviderId::all();
-        assert_eq!(all.len(), 76);
+        assert_eq!(all.len(), 77);
         assert!(all.contains(&ProviderId::Claude));
         assert!(all.contains(&ProviderId::Codex));
+        assert!(all.contains(&ProviderId::Pi));
         assert!(all.contains(&ProviderId::Fireworks));
         assert!(all.contains(&ProviderId::Kimi));
         assert!(all.contains(&ProviderId::KimiK2));
diff --git a/rust/src/core/provider_factory.rs b/rust/src/core/provider_factory.rs
index b8fb6f7f7e..aff4b6f31d 100644
--- a/rust/src/core/provider_factory.rs
+++ b/rust/src/core/provider_factory.rs
@@ -18,10 +18,10 @@ use crate::providers::{
     LongCatProvider, ManusProvider, MetaProvider, MiMoProvider, MiniMaxProvider, MistralProvider,
     MuseProvider, NanoGPTProvider, NeuralwattProvider, NotionProvider, NousProvider,
     OllamaProvider, OpenAIApiProvider, OpenCodeGoProvider, OpenCodeProvider, OpenRouterProvider,
-    PerplexityProvider, PoeProvider, QoderProvider, QwenCloudProvider, ReplicateProvider,
-    SakanaProvider, StepFunProvider, Sub2ApiProvider, T3ChatProvider, VeniceProvider,
-    VertexAIProvider, WarpProvider, WayfinderProvider, WindsurfProvider, XaiProvider, ZaiProvider,
-    ZedProvider, ZenMuxProvider, ZoomMateProvider,
+    PerplexityProvider, PiProvider, PoeProvider, QoderProvider, QwenCloudProvider,
+    ReplicateProvider, SakanaProvider, StepFunProvider, Sub2ApiProvider, T3ChatProvider,
+    VeniceProvider, VertexAIProvider, WarpProvider, WayfinderProvider, WindsurfProvider,
+    XaiProvider, ZaiProvider, ZedProvider, ZenMuxProvider, ZoomMateProvider,
 };
 
 /// Instantiate the concrete [`Provider`] implementation for a given [`ProviderId`].
@@ -32,6 +32,7 @@ pub fn instantiate(id: ProviderId) -> Box<dyn Provider> {
     match id {
         ProviderId::Claude => Box::new(ClaudeProvider::new()),
         ProviderId::Codex => Box::new(CodexProvider::new()),
+        ProviderId::Pi => Box::new(PiProvider::new()),
         ProviderId::Cursor => Box::new(CursorProvider::new()),
         ProviderId::Gemini => Box::new(GeminiProvider::new()),
         ProviderId::Copilot => Box::new(CopilotProvider::new()),
diff --git a/rust/src/core/token_accounts.rs b/rust/src/core/token_accounts.rs
index 0e1b6c076f..a8f3cc71ae 100755
--- a/rust/src/core/token_accounts.rs
+++ b/rust/src/core/token_accounts.rs
@@ -332,6 +332,7 @@ impl TokenAccountSupport {
             }),
             // These providers don't support token accounts
             ProviderId::Codex
+            | ProviderId::Pi
             | ProviderId::Gemini
             | ProviderId::Antigravity
             | ProviderId::Kiro
diff --git a/rust/src/cost_scanner.rs b/rust/src/cost_scanner.rs
index e8b1dd03cd..619f9ba7b0 100755
--- a/rust/src/cost_scanner.rs
+++ b/rust/src/cost_scanner.rs
@@ -523,6 +523,38 @@ impl CostScanner {
         self
     }
 
+    /// Scan standalone Pi and OMP local history.
+    ///
+    /// Pi session rows can represent either Codex or Claude models. They are
+    /// priced with the mapped provider's table but owned by the standalone Pi
+    /// source, so this path never adds native Codex/Claude transcripts.
+    pub fn scan_pi(&self) -> CostSummary {
+        self.scan_pi_with_cancel(None)
+    }
+
+    pub fn scan_pi_with_cancel(&self, cancel: Option<&AtomicBool>) -> CostSummary {
+        let today = Utc::now().date_naive();
+        let mut summary = CostSummary {
+            period_start: Some(today - Duration::days(self.days as i64)),
+            period_end: Some(today),
+            ..CostSummary::default()
+        };
+        let mut seen_entries = HashSet::new();
+        let evidence = crate::pi_session_cost::scan_pi_into(
+            &mut summary,
+            self.days,
+            cancel,
+            &mut seen_entries,
+        );
+        summary.history_coverage_established = evidence.complete && !is_cancelled(cancel);
+        summary.known_zero = summary.history_coverage_established
+            && summary.sessions_count == 0
+            && summary.input_tokens == 0
+            && summary.output_tokens == 0
+            && summary.cached_tokens == 0;
+        summary
+    }
+
     /// Scan Codex local logs
     pub fn scan_claude(&self) -> CostSummary {
         self.scan_claude_with_cancel(None)
@@ -530,6 +562,19 @@ impl CostScanner {
 
     /// Scan Claude local logs, stopping early when the caller cancels the scan.
     pub fn scan_claude_with_cancel(&self, cancel: Option<&AtomicBool>) -> CostSummary {
+        self.scan_claude_with_cancel_and_pi_sessions(cancel, true)
+    }
+
+    /// Scan Claude local logs with optional Pi/OMP-compatible history.
+    ///
+    /// The default scanner remains inclusive for backwards compatibility. A
+    /// combined Codex/Claude/Pi selection can turn this off so the standalone
+    /// Pi row owns those mirrored events exactly once.
+    pub fn scan_claude_with_cancel_and_pi_sessions(
+        &self,
+        cancel: Option<&AtomicBool>,
+        include_pi_sessions: bool,
+    ) -> CostSummary {
         let projects_dir = self.get_claude_projects_dir();
         let mut summary = CostSummary::default();
         let today = Utc::now().date_naive();
@@ -565,14 +610,16 @@ impl CostScanner {
         }
 
         // OMP / pi-compatible anthropic rows, deduped across shared files.
-        let mut seen_pi = HashSet::new();
-        crate::pi_session_cost::scan_pi_compatible_into(
-            &mut summary,
-            crate::pi_session_cost::PiMappedProvider::Claude,
-            self.days,
-            cancel,
-            &mut seen_pi,
-        );
+        if include_pi_sessions {
+            let mut seen_pi = HashSet::new();
+            crate::pi_session_cost::scan_pi_compatible_into(
+                &mut summary,
+                crate::pi_session_cost::PiMappedProvider::Claude,
+                self.days,
+                cancel,
+                &mut seen_pi,
+            );
+        }
 
         // Claude has no persisted provider cost-report cache in the Windows
         // port. Rebuilding from the transcript inventory on every scan makes
@@ -1092,7 +1139,7 @@ pub fn get_daily_cost_history(provider: &str, days: u32) -> Vec<(String, Option<
         let date_str = date.format("%Y-%m-%d").to_string();
         daily_costs.insert(
             date_str,
-            (provider != "codex" && provider != "claude").then_some(0.0),
+            (provider != "codex" && provider != "claude" && provider != "pi").then_some(0.0),
         );
     }
 
@@ -1173,6 +1220,21 @@ pub fn get_daily_cost_history(provider: &str, days: u32) -> Vec<(String, Option<
                 }
             }
         }
+        "pi" => {
+            let scan = crate::pi_session_cost::scan_pi_daily(days, None);
+            for (day_key, cost) in &scan.costs {
+                if let Some(slot) = daily_costs.get_mut(day_key) {
+                    *slot = (!scan.unpriced_days.contains(day_key)).then_some(*cost);
+                }
+            }
+            if scan.history_coverage_established {
+                for (day_key, slot) in &mut daily_costs {
+                    if slot.is_none() && !scan.unpriced_days.contains(day_key) {
+                        *slot = Some(0.0);
+                    }
+                }
+            }
+        }
         _ => {}
     }
 
@@ -1247,6 +1309,17 @@ pub fn get_daily_token_history(provider: &str, days: u32) -> (Vec<(String, u64)>
                 scanner.walk_claude_files(&projects_dir, &cutoff, None, &mut handle_file);
             }
         }
+        "pi" => {
+            let scan = crate::pi_session_cost::scan_pi_daily(days, None);
+            for (day_key, tokens) in scan.tokens {
+                if let Some(slot) = daily_tokens.get_mut(&day_key) {
+                    *slot = tokens;
+                }
+            }
+            if scan.history_coverage_established {
+                covered_days.extend(daily_tokens.keys().cloned());
+            }
+        }
         _ => {}
     }
 
@@ -1257,12 +1330,18 @@ pub fn get_daily_token_history(provider: &str, days: u32) -> (Vec<(String, u64)>
     // Codex only: the bounded catch-up may not have reached the requested
     // depth yet. Incomplete = history exists but the oldest quarter of the
     // window has no scanned day.
-    let incomplete = provider == "codex"
-        && !covered_days.is_empty()
-        && covered_days.len() < days as usize
-        && result[..(result.len() / 4).max(1)]
-            .iter()
-            .any(|(date, _)| !covered_days.contains(date));
+    let incomplete = if provider == "pi" {
+        // Pi scans are bounded filesystem walks, so a complete parse covers
+        // the requested window even when the roots contain no sessions.
+        covered_days.is_empty()
+    } else {
+        provider == "codex"
+            && !covered_days.is_empty()
+            && covered_days.len() < days as usize
+            && result[..(result.len() / 4).max(1)]
+                .iter()
+                .any(|(date, _)| !covered_days.contains(date))
+    };
 
     (result, incomplete)
 }
diff --git a/rust/src/pi_session_cost.rs b/rust/src/pi_session_cost.rs
index e372bec322..a9f8f1b82c 100644
--- a/rust/src/pi_session_cost.rs
+++ b/rust/src/pi_session_cost.rs
@@ -1,10 +1,10 @@
 //! Pi-compatible + OMP agent session cost scan (upstream #2269).
 //!
-//! Walks `~/.pi/agent/sessions/**/*.jsonl` and `~/.omp/agent/sessions/**/*.jsonl`
-//! and attributes openai-codex / anthropic assistant rows into cost summaries
-//! without double-counting the same entry id across shared files.
+//! Resolves Pi-family session roots and walks their JSONL files, attributing
+//! openai-codex / anthropic assistant rows into cost summaries without
+//! double-counting the same entry id across shared files.
 
-use chrono::{DateTime, Duration, Utc};
+use chrono::{DateTime, Duration, Local, Utc};
 use serde_json::Value;
 use std::collections::HashSet;
 use std::fs::File;
@@ -12,8 +12,12 @@ use std::io::{BufRead, BufReader};
 use std::path::{Path, PathBuf};
 use std::sync::atomic::AtomicBool;
 
+use crate::agent_sessions::pi_family::roots::{
+    EnvMap, PiProfile, omp_all_profile_roots, omp_default_profile_root, omp_named_profile_root,
+    omp_profile_selector, pi_settings_session_directory,
+};
 use crate::core::CostUsagePricing;
-use crate::cost_scanner::CostSummary;
+use crate::cost_scanner::{CostSummary, ModelPricingCompleteness};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum PiMappedProvider {
@@ -21,59 +25,254 @@ pub enum PiMappedProvider {
     Claude,
 }
 
+#[derive(Debug, Default)]
+pub struct PiDailyScan {
+    pub costs: std::collections::HashMap<String, f64>,
+    pub tokens: std::collections::HashMap<String, u64>,
+    pub unpriced_days: HashSet<String>,
+    pub history_coverage_established: bool,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct PiScanEvidence {
+    pub complete: bool,
+}
+
+impl Default for PiScanEvidence {
+    fn default() -> Self {
+        Self { complete: true }
+    }
+}
+
 /// Session roots to scan: `.pi` and `.omp` under the user home.
 pub fn pi_compatible_session_roots(home: Option<PathBuf>) -> Vec<PathBuf> {
     let Some(home) = home else {
         return Vec::new();
     };
-    [".pi", ".omp"]
+    let cwd = std::env::current_dir().unwrap_or_else(|_| home.clone());
+    let environment: EnvMap = std::env::vars().collect();
+    pi_compatible_session_roots_for(&home, &cwd, &environment)
+}
+
+fn pi_compatible_session_roots_for(home: &Path, cwd: &Path, environment: &EnvMap) -> Vec<PathBuf> {
+    let mut roots = Vec::new();
+    let pi_root = environment
+        .get("PI_CODING_AGENT_SESSION_DIR")
+        .and_then(|value| resolve_environment_path(value, cwd))
+        .or_else(|| {
+            environment
+                .get("PI_CODING_AGENT_DIR")
+                .and_then(|value| resolve_environment_path(value, cwd))
+                .map(|root| root.join("sessions"))
+        })
+        .or_else(|| pi_settings_session_directory(cwd, home))
+        .unwrap_or_else(|| home.join(".pi").join("agent").join("sessions"));
+    roots.push(pi_root);
+
+    match omp_profile_selector(environment) {
+        PiProfile::Invalid => {}
+        PiProfile::Named(profile) => {
+            if let Some(root) = omp_named_profile_root(&profile, environment, cwd, home) {
+                roots.push(root);
+            }
+        }
+        PiProfile::Default => {
+            if let Some(root) = omp_default_profile_root(environment, cwd, home) {
+                roots.push(root);
+            }
+            roots.extend(omp_all_profile_roots(environment, home));
+        }
+    }
+
+    let mut seen = HashSet::new();
+    roots
         .into_iter()
-        .map(|dir| home.join(dir).join("agent").join("sessions"))
+        .filter(|root| {
+            let key = std::fs::canonicalize(root)
+                .unwrap_or_else(|_| root.clone())
+                .to_string_lossy()
+                .to_ascii_lowercase();
+            seen.insert(key)
+        })
         .collect()
 }
 
+fn resolve_environment_path(value: &str, cwd: &Path) -> Option<PathBuf> {
+    let value = value.trim();
+    if value.is_empty() {
+        return None;
+    }
+    let path = PathBuf::from(value);
+    Some(if path.is_absolute() {
+        path
+    } else {
+        cwd.join(path)
+    })
+}
+
 pub fn scan_pi_compatible_into(
     summary: &mut CostSummary,
     target: PiMappedProvider,
     days: u32,
     cancel: Option<&AtomicBool>,
     seen_entries: &mut HashSet<String>,
-) {
+) -> PiScanEvidence {
+    scan_roots_into(
+        summary,
+        days,
+        cancel,
+        seen_entries,
+        pi_compatible_session_roots(dirs::home_dir()),
+        Some(target),
+    )
+}
+
+/// Scan Pi and OMP history as one standalone provider-owned source.
+///
+/// The compatible Codex/Claude paths above intentionally project these rows
+/// into their native summaries. This path keeps the same parser and pricing,
+/// but accepts both mapped providers and shares one deduplication set across
+/// both roots so standalone Pi history is not double-counted.
+pub fn scan_pi_into(
+    summary: &mut CostSummary,
+    days: u32,
+    cancel: Option<&AtomicBool>,
+    seen_entries: &mut HashSet<String>,
+) -> PiScanEvidence {
+    scan_roots_into(
+        summary,
+        days,
+        cancel,
+        seen_entries,
+        pi_compatible_session_roots(dirs::home_dir()),
+        None,
+    )
+}
+
+/// Scan standalone Pi/OMP history into daily cost and token buckets.
+pub fn scan_pi_daily(days: u32, cancel: Option<&AtomicBool>) -> PiDailyScan {
+    let cutoff = Utc::now() - Duration::days(days as i64);
+    scan_pi_daily_from_roots(
+        cutoff,
+        cancel,
+        pi_compatible_session_roots(dirs::home_dir()),
+    )
+}
+
+fn scan_pi_daily_from_roots(
+    cutoff: DateTime<Utc>,
+    cancel: Option<&AtomicBool>,
+    roots: Vec<PathBuf>,
+) -> PiDailyScan {
+    let mut result = PiDailyScan::default();
+    let mut seen_entries = HashSet::new();
+    let mut missing_timestamp = false;
+    let mut evidence = PiScanEvidence::default();
+    for root in roots {
+        if cancelled(cancel) {
+            break;
+        }
+        if !root.is_dir() {
+            continue;
+        }
+        if !walk_jsonl(&root, cancel, &mut |path| {
+            if cancelled(cancel) {
+                return false;
+            }
+            let file = for_each_pi_entry(path, cutoff, None, &mut seen_entries, |entry| {
+                let Some(timestamp) = entry.timestamp else {
+                    missing_timestamp = true;
+                    return;
+                };
+                let day = timestamp
+                    .with_timezone(&Local)
+                    .date_naive()
+                    .format("%Y-%m-%d")
+                    .to_string();
+                if !entry.pricing_known {
+                    result.unpriced_days.insert(day.clone());
+                }
+                *result.costs.entry(day.clone()).or_insert(0.0) += entry.cost;
+                let tokens = entry.input.saturating_add(entry.output);
+                let total = result.tokens.entry(day.clone()).or_insert(0);
+                *total = total.saturating_add(tokens);
+            });
+            file.complete
+        }) {
+            evidence.complete = false;
+        }
+    }
+    result.history_coverage_established =
+        evidence.complete && !cancelled(cancel) && !missing_timestamp;
+    result
+}
+
+fn scan_roots_into(
+    summary: &mut CostSummary,
+    days: u32,
+    cancel: Option<&AtomicBool>,
+    seen_entries: &mut HashSet<String>,
+    roots: Vec<PathBuf>,
+    target: Option<PiMappedProvider>,
+) -> PiScanEvidence {
     let cutoff = Utc::now() - Duration::days(days as i64);
     let mut sessions = 0u32;
-    for root in pi_compatible_session_roots(dirs::home_dir()) {
+    let mut evidence = PiScanEvidence::default();
+    for root in roots {
         if cancelled(cancel) {
             break;
         }
         if !root.is_dir() {
             continue;
         }
-        walk_jsonl(&root, cancel, &mut |path| {
+        if !walk_jsonl(&root, cancel, &mut |path| {
             if cancelled(cancel) {
-                return;
+                return false;
             }
             let before = seen_entries.len();
-            let counted = for_each_pi_entry(path, cutoff, target, seen_entries, |entry| {
+            let file = for_each_pi_entry(path, cutoff, target, seen_entries, |entry| {
                 apply_entry(summary, &entry);
             });
-            if counted > 0 || seen_entries.len() > before {
+            if file.counted > 0 || seen_entries.len() > before {
                 sessions += 1;
             }
-        });
+            file.complete
+        }) {
+            evidence.complete = false;
+        }
     }
     summary.sessions_count = summary.sessions_count.saturating_add(sessions);
+    evidence
 }
 
 struct PiEntry {
+    timestamp: Option<DateTime<Utc>>,
+    provider: PiMappedProvider,
     model: String,
     input: u64,
     output: u64,
     cache_read: u64,
     cache_create: u64,
     cost: f64,
+    pricing_known: bool,
 }
 
 fn apply_entry(summary: &mut CostSummary, entry: &PiEntry) {
+    if !entry.pricing_known {
+        summary.unknown_models.insert(entry.model.clone());
+        match &mut summary.model_pricing_completeness {
+            ModelPricingCompleteness::Complete => {
+                summary.model_pricing_completeness = ModelPricingCompleteness::Partial {
+                    unpriced_models: vec![entry.model.clone()],
+                };
+            }
+            ModelPricingCompleteness::Partial { unpriced_models } => {
+                if !unpriced_models.contains(&entry.model) {
+                    unpriced_models.push(entry.model.clone());
+                }
+            }
+        }
+    }
     summary.input_tokens += entry.input;
     summary.output_tokens += entry.output;
     summary.cached_tokens += entry.cache_read + entry.cache_create;
@@ -92,62 +291,130 @@ fn cancelled(cancel: Option<&AtomicBool>) -> bool {
     cancel.is_some_and(|f| f.load(std::sync::atomic::Ordering::Relaxed))
 }
 
-fn walk_jsonl(root: &Path, cancel: Option<&AtomicBool>, on_file: &mut dyn FnMut(&Path)) {
+fn walk_jsonl(
+    root: &Path,
+    cancel: Option<&AtomicBool>,
+    on_file: &mut dyn FnMut(&Path) -> bool,
+) -> bool {
     let Ok(entries) = std::fs::read_dir(root) else {
-        return;
+        return false;
     };
-    for entry in entries.flatten() {
+    let mut complete = true;
+    for entry in entries {
         if cancelled(cancel) {
-            return;
+            return false;
         }
+        let Ok(entry) = entry else {
+            complete = false;
+            continue;
+        };
         let path = entry.path();
         if path.is_dir() {
-            walk_jsonl(&path, cancel, on_file);
+            complete = walk_jsonl(&path, cancel, on_file) && complete;
         } else if path
             .extension()
             .and_then(|e| e.to_str())
             .is_some_and(|e| e.eq_ignore_ascii_case("jsonl"))
         {
-            on_file(&path);
+            complete = on_file(&path) && complete;
         }
     }
+    complete
+}
+
+#[derive(Debug, Clone, Copy)]
+struct PiFileScanResult {
+    counted: u32,
+    complete: bool,
 }
 
 fn for_each_pi_entry(
     path: &Path,
     cutoff: DateTime<Utc>,
-    target: PiMappedProvider,
+    target: Option<PiMappedProvider>,
     seen: &mut HashSet<String>,
     mut on_entry: impl FnMut(PiEntry),
-) -> u32 {
+) -> PiFileScanResult {
     let Ok(file) = File::open(path) else {
-        return 0;
+        return PiFileScanResult {
+            counted: 0,
+            complete: false,
+        };
     };
     let mut counted = 0u32;
+    let mut complete = true;
+    let mut session_id = None;
     let reader = BufReader::new(file);
-    for line in reader.lines().map_while(Result::ok) {
+    for (ordinal, line_result) in reader.lines().enumerate() {
+        let Ok(line) = line_result else {
+            complete = false;
+            continue;
+        };
+        if line.trim().is_empty() {
+            continue;
+        }
         let Ok(value) = serde_json::from_str::<Value>(&line) else {
+            complete = false;
             continue;
         };
-        let Some(entry) = parse_pi_assistant_entry(&value, target) else {
+        if session_id.is_none() {
+            session_id = value
+                .get("id")
+                .and_then(|id| id.as_str())
+                .filter(|_| value.get("type").and_then(Value::as_str) == Some("session"))
+                .map(str::to_string);
+        }
+        let Some(entry) = parse_pi_assistant_entry_any(&value) else {
+            if looks_like_usage_candidate(&value) {
+                complete = false;
+            }
             continue;
         };
+        if entry.timestamp.is_none() {
+            complete = false;
+        }
         if let Some(ts) = entry_timestamp(&value)
             && ts < cutoff
         {
             continue;
         }
-        let entry_id = entry_dedup_key(&value, path, counted);
+        if target.is_some_and(|target| entry.provider != target) {
+            continue;
+        }
+        let entry_id = entry_dedup_key(&value, path, ordinal, session_id.as_deref());
         if !seen.insert(entry_id) {
             continue;
         }
         on_entry(entry);
         counted += 1;
     }
-    counted
+    PiFileScanResult { counted, complete }
 }
 
-fn entry_dedup_key(value: &Value, path: &Path, ordinal: u32) -> String {
+fn looks_like_usage_candidate(value: &Value) -> bool {
+    let message = value.get("message").unwrap_or(value);
+    let role = message
+        .get("role")
+        .or_else(|| value.get("role"))
+        .and_then(Value::as_str)
+        .unwrap_or("");
+    let typ = value.get("type").and_then(Value::as_str).unwrap_or("");
+    let assistant_shape = role.eq_ignore_ascii_case("assistant")
+        || typ.eq_ignore_ascii_case("assistant")
+        || typ.eq_ignore_ascii_case("message");
+    assistant_shape
+        && message
+            .get("usage")
+            .or_else(|| value.get("usage"))
+            .is_some()
+}
+
+fn entry_dedup_key(value: &Value, path: &Path, ordinal: usize, session_id: Option<&str>) -> String {
+    // Pi/OMP migrations can mirror the same event into both roots, so a
+    // stable event id wins within the logical session. Scope it with the
+    // session header when available: message IDs can be reused by separate
+    // sessions. The file stem and physical line ordinal cover legacy rows
+    // without a session header or stable message id.
     if let Some(id) = value
         .get("id")
         .or_else(|| value.get("messageId"))
@@ -156,7 +423,14 @@ fn entry_dedup_key(value: &Value, path: &Path, ordinal: u32) -> String {
         .map(str::trim)
         .filter(|s| !s.is_empty())
     {
-        return id.to_string();
+        let scope = session_id
+            .map(str::to_string)
+            .or_else(|| {
+                path.file_stem()
+                    .map(|stem| stem.to_string_lossy().into_owned())
+            })
+            .unwrap_or_else(|| path.display().to_string());
+        return format!("{scope}#{id}");
     }
     format!("{}#{ordinal}", path.display())
 }
@@ -190,7 +464,13 @@ fn map_provider(raw: &str) -> Option<PiMappedProvider> {
     None
 }
 
+#[cfg(test)]
 fn parse_pi_assistant_entry(value: &Value, target: PiMappedProvider) -> Option<PiEntry> {
+    let entry = parse_pi_assistant_entry_any(value)?;
+    (entry.provider == target).then_some(entry)
+}
+
+fn parse_pi_assistant_entry_any(value: &Value) -> Option<PiEntry> {
     // Accept either flat or nested { message: {...} } pi-compatible rows.
     let message = value.get("message").unwrap_or(value);
     let role = message
@@ -216,10 +496,6 @@ fn parse_pi_assistant_entry(value: &Value, target: PiMappedProvider) -> Option<P
         .or_else(|| value.get("api"))
         .and_then(|v| v.as_str())?;
     let mapped = map_provider(provider_raw)?;
-    if mapped != target {
-        return None;
-    }
-
     let model = message
         .get("model")
         .or_else(|| message.get("modelId"))
@@ -271,15 +547,17 @@ fn parse_pi_assistant_entry(value: &Value, target: PiMappedProvider) -> Option<P
         return None;
     }
 
-    let cost = match mapped {
-        PiMappedProvider::Codex => CostUsagePricing::codex_cost_usd_with_cache_write(
+    let (cost, pricing_known) = match mapped {
+        PiMappedProvider::Codex => match CostUsagePricing::codex_cost_usd_with_cache_write(
             &model,
             input,
             cache_read,
             cache_create,
             output,
-        )
-        .unwrap_or(0.0),
+        ) {
+            Some(cost) => (cost, true),
+            None => (0.0, false),
+        },
         PiMappedProvider::Claude => {
             // Token counts come from API usage records and fit within i32;
             // the canonical Claude pricing table takes i32 per-token counts.
@@ -297,27 +575,37 @@ fn parse_pi_assistant_entry(value: &Value, target: PiMappedProvider) -> Option<P
                 cache_create.min(i32::MAX as u64) as i32,
                 output.min(i32::MAX as u64) as i32,
             );
-            CostUsagePricing::claude_cost_usd(&model, input, cache_read, cache_create, output)
-                .unwrap_or_else(|| {
-                    CostUsagePricing::claude_cost_usd(
-                        "claude-sonnet-4-6",
-                        input,
-                        cache_read,
-                        cache_create,
-                        output,
-                    )
-                    .unwrap_or(0.0)
-                })
+            if let Some(cost) =
+                CostUsagePricing::claude_cost_usd(&model, input, cache_read, cache_create, output)
+            {
+                (cost, true)
+            } else {
+                // Preserve the legacy fallback amount for continuity, while
+                // marking the model unknown so callers do not present it as
+                // canonical pricing.
+                let fallback = CostUsagePricing::claude_cost_usd(
+                    "claude-sonnet-4-6",
+                    input,
+                    cache_read,
+                    cache_create,
+                    output,
+                )
+                .unwrap_or(0.0);
+                (fallback, false)
+            }
         }
     };
 
     Some(PiEntry {
+        timestamp: entry_timestamp(value),
+        provider: mapped,
         model,
         input,
         output,
         cache_read,
         cache_create,
         cost,
+        pricing_known,
     })
 }
 
@@ -380,6 +668,7 @@ mod tests {
         assert_eq!(entry.output, 20);
         assert_eq!(entry.cache_read, 10);
         assert_eq!(entry.model, "gpt-5");
+        assert!(entry.pricing_known);
     }
 
     #[test]
@@ -400,6 +689,63 @@ mod tests {
         let expected = 500.0 * 1e-5 + 200.0 * 1e-6 + 300.0 * 1.25e-5 + 100.0 * 5e-5;
         assert_eq!(entry.cache_create, 300);
         assert!((entry.cost - expected).abs() < 1e-12);
+        assert!(entry.pricing_known);
+    }
+
+    #[test]
+    fn unknown_model_keeps_tokens_and_marks_pricing_incomplete() {
+        let raw = serde_json::json!({
+            "id": "unknown-model-1",
+            "role": "assistant",
+            "provider": "openai-codex",
+            "model": "future-model-without-a-rate",
+            "usage": { "input": 11, "output": 3 }
+        });
+        let entry = parse_pi_assistant_entry_any(&raw).unwrap();
+        assert!(!entry.pricing_known);
+        assert_eq!(entry.cost, 0.0);
+
+        let mut summary = CostSummary::default();
+        apply_entry(&mut summary, &entry);
+        assert_eq!(summary.input_tokens, 11);
+        assert_eq!(summary.output_tokens, 3);
+        assert!(
+            summary
+                .unknown_models
+                .contains("future-model-without-a-rate")
+        );
+        assert!(summary.model_pricing_completeness.is_partial());
+    }
+
+    #[test]
+    fn standalone_parser_keeps_the_mapped_provider_for_mixed_history() {
+        let codex = serde_json::json!({
+            "id": "codex-1",
+            "role": "assistant",
+            "provider": "openai-codex",
+            "model": "gpt-5",
+            "usage": { "input": 100, "output": 20 }
+        });
+        let claude = serde_json::json!({
+            "id": "claude-1",
+            "role": "assistant",
+            "provider": "anthropic",
+            "model": "claude-sonnet-4-6",
+            "usage": { "input": 100, "output": 20 }
+        });
+
+        assert_eq!(
+            parse_pi_assistant_entry_any(&codex)
+                .expect("Codex row should parse")
+                .provider,
+            PiMappedProvider::Codex
+        );
+        assert_eq!(
+            parse_pi_assistant_entry_any(&claude)
+                .expect("Claude row should parse")
+                .provider,
+            PiMappedProvider::Claude
+        );
     }
 
     #[test]
@@ -407,9 +753,11 @@ mod tests {
         let dir = tempdir().unwrap();
         let sessions = dir.path().join("agent").join("sessions");
         std::fs::create_dir_all(&sessions).unwrap();
+        let header = r#"{"type":"session","id":"session-1"}"#;
         let line = r#"{"id":"shared-1","role":"assistant","provider":"openai-codex","model":"gpt-5","timestamp":"2026-07-20T12:00:00Z","usage":{"input":50,"output":5}}"#;
         for name in ["a.jsonl", "b.jsonl"] {
             let mut f = File::create(sessions.join(name)).unwrap();
+            writeln!(f, "{header}").unwrap();
             writeln!(f, "{line}").unwrap();
         }
 
@@ -425,10 +773,11 @@ mod tests {
                 DateTime::parse_from_rfc3339("2026-07-01T00:00:00Z")
                     .unwrap()
                     .with_timezone(&Utc),
-                PiMappedProvider::Codex,
+                Some(PiMappedProvider::Codex),
                 &mut seen,
                 |entry| apply_entry(&mut summary, &entry),
-            );
+            )
+            .counted;
         }
         assert_eq!(seen.len(), 1);
         assert_eq!(summary.input_tokens, 50);
@@ -436,9 +785,153 @@ mod tests {
         let _ = home;
     }
 
+    #[test]
+    fn same_message_id_in_distinct_sessions_is_not_deduped() {
+        let dir = tempdir().unwrap();
+        let sessions = dir.path().join("agent").join("sessions");
+        std::fs::create_dir_all(&sessions).unwrap();
+        let line = r#"{"id":"reused-message","role":"assistant","provider":"openai-codex","model":"gpt-5","timestamp":"2026-07-20T12:00:00Z","usage":{"input":50,"output":5}}"#;
+        for session in ["session-a", "session-b"] {
+            let mut f = File::create(sessions.join(format!("{session}.jsonl"))).unwrap();
+            writeln!(f, "{{\"type\":\"session\",\"id\":\"{session}\"}}").unwrap();
+            writeln!(f, "{line}").unwrap();
+        }
+
+        let cutoff = DateTime::parse_from_rfc3339("2026-07-01T00:00:00Z")
+            .unwrap()
+            .with_timezone(&Utc);
+        let mut seen = HashSet::new();
+        let mut summary = CostSummary::default();
+        let mut total = 0u32;
+        for session in ["session-a", "session-b"] {
+            total += for_each_pi_entry(
+                &sessions.join(format!("{session}.jsonl")),
+                cutoff,
+                Some(PiMappedProvider::Codex),
+                &mut seen,
+                |entry| apply_entry(&mut summary, &entry),
+            )
+            .counted;
+        }
+        assert_eq!(total, 2);
+        assert_eq!(summary.input_tokens, 100);
+    }
+
+    #[test]
+    fn configured_roots_include_explicit_pi_and_omp_profile_sources() {
+        let home = tempdir().unwrap();
+        let cwd = home.path().join("project");
+        std::fs::create_dir_all(&cwd).unwrap();
+        let mut environment = EnvMap::new();
+        environment.insert(
+            "PI_CODING_AGENT_SESSION_DIR".to_string(),
+            "pi-sessions".to_string(),
+        );
+        environment.insert("PI_CONFIG_DIR".to_string(), "config".to_string());
+        environment.insert("OMP_PROFILE".to_string(), "work".to_string());
+
+        let roots = pi_compatible_session_roots_for(home.path(), &cwd, &environment);
+        let pi_root = cwd.join("pi-sessions");
+        let omp_root = home
+            .path()
+            .join("config")
+            .join("profiles")
+            .join("work")
+            .join("agent")
+            .join("sessions");
+        assert!(roots.iter().any(|root| root == &pi_root));
+        assert!(roots.iter().any(|root| root == &omp_root));
+
+        let duplicate = concat!(
+            r#"{"type":"session","id":"session-1"}"#,
+            "\n",
+            r#"{"id":"shared","role":"assistant","provider":"openai-codex","model":"gpt-5","timestamp":"2026-07-20T12:00:00Z","usage":{"input":50,"output":5}}"#,
+            "\n"
+        );
+        let unique = concat!(
+            r#"{"type":"session","id":"session-2"}"#,
+            "\n",
+            r#"{"id":"unique","role":"assistant","provider":"anthropic","model":"claude-sonnet-4-6","timestamp":"2026-07-20T13:00:00Z","usage":{"input":70,"output":7}}"#,
+            "\n"
+        );
+        std::fs::create_dir_all(&pi_root).unwrap();
+        std::fs::create_dir_all(&omp_root).unwrap();
+        std::fs::write(pi_root.join("session.jsonl"), duplicate).unwrap();
+        std::fs::write(omp_root.join("session.jsonl"), duplicate).unwrap();
+        std::fs::write(omp_root.join("unique.jsonl"), unique).unwrap();
+
+        let scan = scan_pi_daily_from_roots(
+            DateTime::parse_from_rfc3339("2026-07-01T00:00:00Z")
+                .unwrap()
+                .with_timezone(&Utc),
+            None,
+            roots,
+        );
+        assert!(scan.history_coverage_established);
+        assert_eq!(scan.tokens.values().sum::<u64>(), 132);
+    }
+
+    #[test]
+    fn malformed_usage_input_keeps_valid_rows_but_marks_source_incomplete() {
+        let dir = tempdir().unwrap();
+        let sessions = dir.path().join("agent").join("sessions");
+        std::fs::create_dir_all(&sessions).unwrap();
+        let valid = r#"{"id":"valid","role":"assistant","provider":"openai-codex","model":"gpt-5","timestamp":"2026-07-20T12:00:00Z","usage":{"input":11,"output":3}}"#;
+        std::fs::write(
+            sessions.join("mixed.jsonl"),
+            format!("{valid}\n{{\"role\":\"assistant\",\"usage\":\n"),
+        )
+        .unwrap();
+
+        let scan = scan_pi_daily_from_roots(
+            DateTime::parse_from_rfc3339("2026-07-01T00:00:00Z")
+                .unwrap()
+                .with_timezone(&Utc),
+            None,
+            vec![sessions.clone()],
+        );
+        assert!(!scan.history_coverage_established);
+        assert_eq!(scan.tokens.values().sum::<u64>(), 14);
+
+        let mut summary = CostSummary::default();
+        let mut seen = HashSet::new();
+        let evidence = scan_roots_into(&mut summary, 365, None, &mut seen, vec![sessions], None);
+        assert!(!evidence.complete);
+        assert_eq!(summary.input_tokens, 11);
+    }
+
+    #[test]
+    fn standalone_daily_scan_dedupes_pi_and_omp_roots() {
+        let dir = tempdir().unwrap();
+        let pi_sessions = dir.path().join(".pi").join("agent").join("sessions");
+        let omp_sessions = dir.path().join(".omp").join("agent").join("sessions");
+        std::fs::create_dir_all(&pi_sessions).unwrap();
+        std::fs::create_dir_all(&omp_sessions).unwrap();
+        let codex = r#"{"id":"shared","role":"assistant","provider":"openai-codex","model":"gpt-5","timestamp":"2026-07-20T12:00:00Z","usage":{"input":50,"output":5}}"#;
+        let claude = r#"{"id":"claude-only","role":"assistant","provider":"anthropic","model":"claude-sonnet-4-6","timestamp":"2026-07-20T13:00:00Z","usage":{"input":70,"output":7}}"#;
+        std::fs::write(
+            pi_sessions.join("one.jsonl"),
+            format!("{codex}\n{claude}\n"),
+        )
+        .unwrap();
+        std::fs::write(omp_sessions.join("one.jsonl"), format!("{codex}\n")).unwrap();
+
+        let scan = scan_pi_daily_from_roots(
+            DateTime::parse_from_rfc3339("2026-07-01T00:00:00Z")
+                .unwrap()
+                .with_timezone(&Utc),
+            None,
+            vec![pi_sessions, omp_sessions],
+        );
+        assert!(scan.history_coverage_established);
+        assert_eq!(scan.tokens.values().sum::<u64>(), 132);
+        assert_eq!(scan.tokens.len(), 1);
+    }
+
     #[test]
     fn session_roots_include_pi_and_omp() {
-        let roots = pi_compatible_session_roots(Some(PathBuf::from("/home/user")));
+        let home = PathBuf::from("/home/user");
+        let roots = pi_compatible_session_roots_for(&home, &home, &EnvMap::new());
         assert!(
             roots
                 .iter()
diff --git a/rust/src/providers/mod.rs b/rust/src/providers/mod.rs
index 6ac5e0f1a8..ad697ad321 100755
--- a/rust/src/providers/mod.rs
+++ b/rust/src/providers/mod.rs
@@ -65,6 +65,7 @@ pub mod opencode;
 pub mod opencodego;
 pub mod openrouter;
 pub mod perplexity;
+pub mod pi;
 pub mod poe;
 pub mod qoder;
 pub mod qwencloud;
@@ -143,6 +144,7 @@ pub use opencode::OpenCodeProvider;
 pub use opencodego::OpenCodeGoProvider;
 pub use openrouter::OpenRouterProvider;
 pub use perplexity::PerplexityProvider;
+pub use pi::PiProvider;
 pub use poe::PoeProvider;
 pub use qoder::QoderProvider;
 pub use qwencloud::QwenCloudProvider;
diff --git a/rust/src/providers/pi.rs b/rust/src/providers/pi.rs
new file mode 100644
index 0000000000..862f069abc
--- /dev/null
+++ b/rust/src/providers/pi.rs
@@ -0,0 +1,87 @@
+//! Local Pi provider.
+//!
+//! Pi has no remote quota endpoint in the upstream provider model. Its usage
+//! and token-cost history come from local Pi/OMP session JSONL files; the
+//! ordinary provider refresh therefore exposes an informational local row and
+//! leaves cost history to the dedicated scanner path.
+
+use async_trait::async_trait;
+
+use crate::core::{
+    FetchContext, Provider, ProviderError, ProviderFetchResult, ProviderId, ProviderMetadata,
+    RateWindow, SourceMode, UsageSnapshot,
+};
+
+pub struct PiProvider {
+    metadata: ProviderMetadata,
+}
+
+impl PiProvider {
+    pub fn new() -> Self {
+        Self {
+            metadata: ProviderMetadata {
+                id: ProviderId::Pi,
+                display_name: "Pi",
+                session_label: "Session",
+                weekly_label: "Weekly",
+                supports_opus: false,
+                supports_credits: false,
+                default_enabled: false,
+                is_primary: false,
+                dashboard_url: Some("https://github.com/badlogic/pi-mono"),
+                status_page_url: None,
+                tertiary_label_key: None,
+            },
+        }
+    }
+}
+
+impl Default for PiProvider {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait]
+impl Provider for PiProvider {
+    fn id(&self) -> ProviderId {
+        ProviderId::Pi
+    }
+
+    fn metadata(&self) -> &ProviderMetadata {
+        &self.metadata
+    }
+
+    async fn fetch_usage(&self, ctx: &FetchContext) -> Result<ProviderFetchResult, ProviderError> {
+        if ctx.source_mode != SourceMode::Auto {
+            return Err(ProviderError::UnsupportedSource(ctx.source_mode));
+        }
+
+        Ok(ProviderFetchResult::new(
+            UsageSnapshot::new(RateWindow::informational("Local Pi history")),
+            "local",
+        )
+        .with_non_authoritative_pace())
+    }
+
+    fn available_sources(&self) -> Vec<SourceMode> {
+        vec![SourceMode::Auto]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn exposes_local_only_metadata() {
+        let provider = PiProvider::new();
+        assert_eq!(provider.id(), ProviderId::Pi);
+        assert_eq!(provider.metadata().display_name, "Pi");
+        assert!(!provider.metadata().default_enabled);
+        assert_eq!(provider.available_sources(), vec![SourceMode::Auto]);
+        assert!(!provider.supports_oauth());
+        assert!(!provider.supports_web());
+        assert!(!provider.supports_cli());
+    }
+}
diff --git a/rust/src/spend_contract.rs b/rust/src/spend_contract.rs
index 9a2e928b34..af9cdfef34 100644
--- a/rust/src/spend_contract.rs
+++ b/rust/src/spend_contract.rs
@@ -346,6 +346,7 @@ pub fn build_local_spend_contract(
     let summary = match provider_id {
         "codex" => scanner.scan_codex(),
         "claude" => scanner.scan_claude(),
+        "pi" => scanner.scan_pi(),
         "opencodego" => scanner.scan_opencodego_with_cancel(None),
         _ => CostSummary::default(),
     };