diff --git a/apps/desktop-tauri/src-tauri/src/commands/provider_settings.rs b/apps/desktop-tauri/src-tauri/src/commands/provider_settings.rs
index 4028a688e9..3aa5518b59 100644
--- a/apps/desktop-tauri/src-tauri/src/commands/provider_settings.rs
+++ b/apps/desktop-tauri/src-tauri/src/commands/provider_settings.rs
@@ -334,6 +334,7 @@ fn workspace_provider(provider_id: &str) -> Option<codexbar::core::ProviderId> {
         "xai" => ProviderId::Xai,
         "v0" => ProviderId::V0,
         "helmcode" => ProviderId::Helmcode,
+        "gitkraken" => ProviderId::GitKraken,
         _ => return None,
     })
 }
@@ -389,7 +390,7 @@ fn litellm_workspace_change_allowed(
 mod tests {
     use codexbar::core::ProviderId;
 
-    use super::{litellm_workspace_change_allowed, workspace_provider};
+    use super::{gateway_provider, litellm_workspace_change_allowed, workspace_provider};
 
     #[test]
     fn maps_opencode_go_workspace_provider() {
@@ -399,6 +400,18 @@ mod tests {
         );
     }
 
+    #[test]
+    fn maps_gitkraken_organization_provider() {
+        assert_eq!(workspace_provider("gitkraken"), Some(ProviderId::GitKraken));
+    }
+
+    #[test]
+    fn gateway_provider_exposes_wayfinder_and_bifrost_only() {
+        assert_eq!(gateway_provider("wayfinder"), Some(ProviderId::Wayfinder));
+        assert_eq!(gateway_provider("bifrost"), Some(ProviderId::Bifrost));
+        assert_eq!(gateway_provider("codex"), None);
+    }
+
     #[test]
     fn litellm_endpoint_change_requires_reentering_saved_key() {
         assert!(
@@ -450,7 +463,18 @@ pub fn get_provider_workspace_id(provider_id: String) -> Result<Option<String>,
 }
 
 fn gateway_provider(provider_id: &str) -> Option<codexbar::core::ProviderId> {
-    (provider_id == "wayfinder").then_some(codexbar::core::ProviderId::Wayfinder)
+    match provider_id {
+        "wayfinder" => Some(codexbar::core::ProviderId::Wayfinder),
+        "bifrost" => Some(codexbar::core::ProviderId::Bifrost),
+        _ => None,
+    }
+}
+
+#[tauri::command]
+pub fn get_provider_gateway_url(provider_id: String) -> Result<String, String> {
+    let id = gateway_provider(&provider_id)
+        .ok_or_else(|| format!("Provider '{provider_id}' does not expose a gateway URL"))?;
+    Ok(Settings::load().gateway_url(id).to_string())
 }
 
 #[tauri::command]
@@ -458,8 +482,17 @@ pub fn set_provider_gateway_url(provider_id: String, gateway_url: String) -> Res
     let id = gateway_provider(&provider_id)
         .ok_or_else(|| format!("Provider '{provider_id}' does not expose a gateway URL"))?;
     let gateway_url = gateway_url.trim();
-    codexbar::providers::wayfinder::parse_gateway_url(gateway_url)
-        .map_err(|error| error.to_string())?;
+    match id {
+        codexbar::core::ProviderId::Wayfinder => {
+            codexbar::providers::wayfinder::parse_gateway_url(gateway_url)
+                .map_err(|error| error.to_string())?;
+        }
+        codexbar::core::ProviderId::Bifrost => {
+            codexbar::providers::bifrost::validate_gateway_url(gateway_url)
+                .map_err(|error| error.to_string())?;
+        }
+        _ => unreachable!("gateway_provider only returns gateway providers"),
+    }
 
     let mut settings = Settings::load();
     settings.set_gateway_url(id, gateway_url.to_string());
diff --git a/apps/desktop-tauri/src-tauri/src/main.rs b/apps/desktop-tauri/src-tauri/src/main.rs
index 347160e42b..30f6132c92 100644
--- a/apps/desktop-tauri/src-tauri/src/main.rs
+++ b/apps/desktop-tauri/src-tauri/src/main.rs
@@ -303,6 +303,7 @@ fn main() {
             commands::get_provider_region_options,
             commands::set_provider_workspace_id,
             commands::set_provider_gateway_url,
+            commands::get_provider_gateway_url,
             commands::get_provider_workspace_id,
             commands::get_gemini_cli_signed_in,
             commands::get_vertexai_status,
diff --git a/apps/desktop-tauri/src/components/providers/providerIcons.ts b/apps/desktop-tauri/src/components/providers/providerIcons.ts
index aefe0035aa..ee24a2c1f1 100644
--- a/apps/desktop-tauri/src/components/providers/providerIcons.ts
+++ b/apps/desktop-tauri/src/components/providers/providerIcons.ts
@@ -185,7 +185,10 @@ export const PROVIDER_ICON_REGISTRY: Record<string, ProviderIcon> = {
   gemini:      { id: "gemini",      brandColor: "#ab87ea", fallbackLetter: "✦", svgPath: RAW.gemini },
   grok:        { id: "grok",        brandColor: "#111827", fallbackLetter: "G", svgPath: RAW.grok },
   groq:        { id: "groq",        brandColor: "#f55036", fallbackLetter: "G", svgPath: RAW.groq },
+  bifrost:     { id: "bifrost",     brandColor: "#5b7cfa", fallbackLetter: "B" },
+  gitkraken:   { id: "gitkraken",   brandColor: "#179287", fallbackLetter: "G" },
   huggingface: { id: "huggingface", brandColor: "#ffd21e", fallbackLetter: "H", svgPath: RAW.huggingface },
+  hyper:       { id: "hyper",       brandColor: "#7c3aed", fallbackLetter: "H" },
   helmcode:    { id: "helmcode",    brandColor: "#4f46e5", fallbackLetter: "H" },
   v0:          { id: "v0",          brandColor: "#111827", fallbackLetter: "V" },
   typesafe:    { id: "typesafe",    brandColor: "#2563eb", fallbackLetter: "T" },
diff --git a/apps/desktop-tauri/src/lib/tauri.ts b/apps/desktop-tauri/src/lib/tauri.ts
index 6ccd63c0de..57f6ce274d 100644
--- a/apps/desktop-tauri/src/lib/tauri.ts
+++ b/apps/desktop-tauri/src/lib/tauri.ts
@@ -450,6 +450,10 @@ export function setProviderGatewayUrl(
   return invoke<void>("set_provider_gateway_url", { providerId, gatewayUrl });
 }
 
+export function getProviderGatewayUrl(providerId: string): Promise<string> {
+  return invoke<string>("get_provider_gateway_url", { providerId });
+}
+
 export function getProviderAzureApiVersion(providerId: string): Promise<string | null> {
   return invoke<string | null>("get_provider_azure_api_version", { providerId });
 }
diff --git a/apps/desktop-tauri/src/surfaces/settings/providers/ProviderDetailPane.tsx b/apps/desktop-tauri/src/surfaces/settings/providers/ProviderDetailPane.tsx
index 0dadfe492d..ae3e6766a5 100644
--- a/apps/desktop-tauri/src/surfaces/settings/providers/ProviderDetailPane.tsx
+++ b/apps/desktop-tauri/src/surfaces/settings/providers/ProviderDetailPane.tsx
@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useReducer } from "react";
+import { useCallback, useEffect, useReducer, useState } from "react";
 import type { SettingsSnapshot, SettingsUpdate } from "../../../types/bridge";
 import { useLocale } from "../../../hooks/useLocale";
 import { providerAllowsPace } from "../../../lib/providerPace";
@@ -6,6 +6,7 @@ import {
   getCredentialStorageStatus,
   getProviderCookieSourceOptions,
   getProviderDetail,
+  getProviderGatewayUrl,
   getProviderRegionOptions,
   getTokenAccountProviders,
   openProviderDashboard,
@@ -83,6 +84,8 @@ export function ProviderDetailPane({
   onSettingsChange,
 }: Props) {
   const { t, language } = useLocale();
+  const [gatewayLoadedProviderId, setGatewayLoadedProviderId] =
+    useState<string | null>(null);
   const [state, dispatch] = useReducer(
     providerDetailPaneReducer,
     { wayfinderGatewayUrl, providerId },
@@ -142,11 +145,34 @@ export function ProviderDetailPane({
     }
   }, []);
 
+  const gatewayProviderId = providerId === "wayfinder" || providerId === "bifrost"
+    ? providerId
+    : null;
+
+  useEffect(() => {
+    setGatewayLoadedProviderId(null);
+    if (!gatewayProviderId) return;
+    let cancelled = false;
+    void getProviderGatewayUrl(gatewayProviderId).then((url) => {
+      if (!cancelled) {
+        dispatch({ type: "SET_GATEWAY_DRAFT", draft: url });
+        setGatewayLoadedProviderId(gatewayProviderId);
+      }
+    }).catch((e) => {
+      if (!cancelled) {
+        dispatch({ type: "SAVE_GATEWAY_ERROR", error: String(e) });
+        setGatewayLoadedProviderId(gatewayProviderId);
+      }
+    });
+    return () => { cancelled = true; };
+  }, [gatewayProviderId]);
+
   const saveGateway = async () => {
     dispatch({ type: "SAVE_GATEWAY_START" });
     try {
-      await setProviderGatewayUrl("wayfinder", gatewayDraft);
-      await load("wayfinder");
+      if (!gatewayProviderId) return;
+      await setProviderGatewayUrl(gatewayProviderId, gatewayDraft);
+      await load(gatewayProviderId);
     } catch (e) {
       dispatch({ type: "SAVE_GATEWAY_ERROR", error: String(e) });
     } finally {
@@ -319,7 +345,8 @@ export function ProviderDetailPane({
         t={t}
         onChanged={reload}
       />
-      {detail.id === "wayfinder" && (
+      {(detail.id === "wayfinder" || detail.id === "bifrost") &&
+        gatewayLoadedProviderId === detail.id && (
         <WayfinderGatewaySection
           draft={gatewayDraft}
           error={gatewayError}
@@ -330,6 +357,7 @@ export function ProviderDetailPane({
           }
           onSave={() => void saveGateway()}
           t={t}
+          bifrost={detail.id === "bifrost"}
         />
       )}
       <MenuBarMetricSection
diff --git a/apps/desktop-tauri/src/surfaces/settings/providers/sections/CredentialsDispatcher.tsx b/apps/desktop-tauri/src/surfaces/settings/providers/sections/CredentialsDispatcher.tsx
index 76c2652ecd..9e57c58d1d 100644
--- a/apps/desktop-tauri/src/surfaces/settings/providers/sections/CredentialsDispatcher.tsx
+++ b/apps/desktop-tauri/src/surfaces/settings/providers/sections/CredentialsDispatcher.tsx
@@ -40,6 +40,7 @@ export function CredentialsDispatcher({ providerId, t }: Props) {
     case "zed":
     case "sub2api":
     case "xai":
+    case "gitkraken":
       return <OpenAiExtras providerId={providerId} t={t} />;
     case "openrouter":
       return <OpenRouterManagementCreds t={t} />;
diff --git a/apps/desktop-tauri/src/surfaces/settings/providers/sections/WayfinderGatewaySection.tsx b/apps/desktop-tauri/src/surfaces/settings/providers/sections/WayfinderGatewaySection.tsx
index 1f0f28f0e6..77b4067771 100644
--- a/apps/desktop-tauri/src/surfaces/settings/providers/sections/WayfinderGatewaySection.tsx
+++ b/apps/desktop-tauri/src/surfaces/settings/providers/sections/WayfinderGatewaySection.tsx
@@ -8,6 +8,7 @@ interface Props {
   onDraftChange: (draft: string) => void;
   onSave: () => void;
   t: (key: LocaleKey) => string;
+  bifrost?: boolean;
 }
 
 export function WayfinderGatewaySection({
@@ -18,12 +19,13 @@ export function WayfinderGatewaySection({
   onDraftChange,
   onSave,
   t,
+  bifrost = false,
 }: Props) {
   return (
     <section className="provider-detail__section">
-      <h3>{t("WayfinderGatewayTitle")}</h3>
+      <h3>{bifrost ? "Bifrost gateway" : t("WayfinderGatewayTitle")}</h3>
       <label>
-        <span>{t("WayfinderGatewayLabel")}</span>
+        <span>{bifrost ? "Gateway URL" : t("WayfinderGatewayLabel")}</span>
         <input
           type="url"
           value={draft}
@@ -32,7 +34,9 @@ export function WayfinderGatewaySection({
           aria-describedby="wayfinder-gateway-help"
         />
       </label>
-      <p id="wayfinder-gateway-help">{t("WayfinderGatewayHelp")}</p>
+      <p id="wayfinder-gateway-help">
+        {bifrost ? "Base URL of your Bifrost gateway." : t("WayfinderGatewayHelp")}
+      </p>
       {error && <p role="alert">{error}</p>}
       <button
         type="button"
diff --git a/apps/desktop-tauri/src/surfaces/settings/providers/sections/credentials/OpenAiExtras.tsx b/apps/desktop-tauri/src/surfaces/settings/providers/sections/credentials/OpenAiExtras.tsx
index 3ed6842890..651436c2e8 100644
--- a/apps/desktop-tauri/src/surfaces/settings/providers/sections/credentials/OpenAiExtras.tsx
+++ b/apps/desktop-tauri/src/surfaces/settings/providers/sections/credentials/OpenAiExtras.tsx
@@ -116,6 +116,7 @@ const WORKSPACE_EXTRA_IDS: Record<string, true> = {
   sub2api: true,
   xai: true,
   fireworks: true,
+  gitkraken: true,
 };
 
 function extraConfig(providerId: string, t: Props["t"]) {
@@ -176,6 +177,13 @@ function extraConfig(providerId: string, t: Props["t"]) {
         placeholder: "your-account-slug",
         help: "From app.fireworks.ai/accounts/<slug>. Or set FIREWORKS_ACCOUNT_SLUG. Pair with a Fireworks API key to read 30-day rated billing spend.",
       };
+    case "gitkraken":
+      return {
+        title: "GitKraken organization",
+        label: "Organization ID (optional)",
+        placeholder: "organization-id",
+        help: "Adds the organization ID to shared-pool usage requests. Or set GITKRAKEN_ORG_ID.",
+      };
     default:
       return null;
   }
diff --git a/apps/desktop-tauri/src/surfaces/settings/providers/sections/usageSourcePolicy.ts b/apps/desktop-tauri/src/surfaces/settings/providers/sections/usageSourcePolicy.ts
index 21de240c09..57ab1c71d5 100644
--- a/apps/desktop-tauri/src/surfaces/settings/providers/sections/usageSourcePolicy.ts
+++ b/apps/desktop-tauri/src/surfaces/settings/providers/sections/usageSourcePolicy.ts
@@ -46,6 +46,25 @@ const POLICIES: Readonly<Record<string, UsageSourcePolicy>> = {
       { value: "oauth", label: "Hermes OAuth", description: "Uses the read-only Nous Portal token from Hermes Agent." },
     ],
   },
+  hyper: {
+    options: [
+      { value: "auto", label: "Auto", description: "Tries the Charm Hyper browser session, then the configured API key." },
+      { value: "web", label: "Browser session", description: "Uses the selected hyper.charm.land browser session only." },
+      { value: "oauth", label: "API", description: "Uses the configured Charm Hyper API key only." },
+    ],
+  },
+  gitkraken: {
+    options: [
+      { value: "auto", label: "Auto", description: "Uses the configured GitKraken access token." },
+      { value: "oauth", label: "API", description: "Uses the configured GitKraken access token only." },
+    ],
+  },
+  bifrost: {
+    options: [
+      { value: "auto", label: "Auto", description: "Uses the configured Bifrost gateway and virtual key." },
+      { value: "oauth", label: "API", description: "Uses the configured Bifrost gateway and virtual key only." },
+    ],
+  },
   muse: {
     options: [
       { value: "auto", label: "Auto", description: "Uses the local Muse Code device login." },
diff --git a/apps/desktop-tauri/src/test/providerCatalog.ts b/apps/desktop-tauri/src/test/providerCatalog.ts
index be41e7b35e..1b1802bc57 100644
--- a/apps/desktop-tauri/src/test/providerCatalog.ts
+++ b/apps/desktop-tauri/src/test/providerCatalog.ts
@@ -76,4 +76,7 @@ export const TEST_PROVIDER_CATALOG: Array<[string, string]> = [
   ["meta", "Meta"],
   ["muse", "Muse Code"],
   ["nous", "Nous Portal"],
+  ["hyper", "Charm Hyper"],
+  ["gitkraken", "GitKraken AI"],
+  ["bifrost", "Bifrost"],
 ];
diff --git a/rust/src/core/provider.rs b/rust/src/core/provider.rs
index 218901b770..868b66fde6 100755
--- a/rust/src/core/provider.rs
+++ b/rust/src/core/provider.rs
@@ -92,6 +92,9 @@ pub enum ProviderId {
     Muse,
     Replicate,
     Nous,
+    Hyper,
+    GitKraken,
+    Bifrost,
 }
 
 impl ProviderId {
@@ -177,6 +180,9 @@ impl ProviderId {
             ProviderId::Muse,
             ProviderId::Replicate,
             ProviderId::Nous,
+            ProviderId::Hyper,
+            ProviderId::GitKraken,
+            ProviderId::Bifrost,
         ]
     }
 
@@ -224,6 +230,9 @@ impl ProviderId {
             ProviderId::Meta => "meta",
             ProviderId::Muse => "muse",
             ProviderId::Nous => "nous",
+            ProviderId::Hyper => "hyper",
+            ProviderId::GitKraken => "gitkraken",
+            ProviderId::Bifrost => "bifrost",
             ProviderId::AiAnd => "aiand",
             ProviderId::Windsurf => "windsurf",
             ProviderId::Manus => "manus",
@@ -310,6 +319,9 @@ impl ProviderId {
             ProviderId::Meta => "Meta",
             ProviderId::Muse => "Muse Code",
             ProviderId::Nous => "Nous Portal",
+            ProviderId::Hyper => "Charm Hyper",
+            ProviderId::GitKraken => "GitKraken AI",
+            ProviderId::Bifrost => "Bifrost",
             ProviderId::AiAnd => "ai&",
             ProviderId::Windsurf => "Windsurf",
             ProviderId::Manus => "Manus",
@@ -411,6 +423,9 @@ impl ProviderId {
             ProviderId::Meta => None,
             ProviderId::Muse => None,
             ProviderId::Nous => None,
+            ProviderId::Hyper => Some("hyper.charm.land"),
+            ProviderId::GitKraken => None,
+            ProviderId::Bifrost => None,
             ProviderId::AiAnd => None,
             ProviderId::Windsurf => None,
             ProviderId::Doubao => None,
@@ -490,6 +505,9 @@ impl ProviderId {
             "fireworks" | "fireworks-ai" | "fw" => Some(ProviderId::Fireworks),
             "muse" | "muse-code" | "muse code" => Some(ProviderId::Muse),
             "nous" | "nous-portal" | "nous portal" | "hermes" => Some(ProviderId::Nous),
+            "hyper" | "charm-hyper" | "charm hyper" => Some(ProviderId::Hyper),
+            "gitkraken" | "gitkraken-ai" | "gitkraken ai" => Some(ProviderId::GitKraken),
+            "bifrost" | "bifrost-gateway" | "bifrost gateway" => Some(ProviderId::Bifrost),
             "meta" | "metaspark" | "meta-spark" | "muse-spark" | "musespark" | "muse spark"
             | "meta muse spark" => Some(ProviderId::Meta),
             "aiand" | "ai&" | "ai-and" | "ai and" => Some(ProviderId::AiAnd),
@@ -1099,6 +1117,9 @@ pub fn brand_color(id: ProviderId) -> &'static str {
         ProviderId::Muse => "#0668E1",
         ProviderId::Replicate => "#000000",
         ProviderId::Nous => "#D6A55C",
+        ProviderId::Hyper => "#7C3AED",
+        ProviderId::GitKraken => "#179287",
+        ProviderId::Bifrost => "#5B7CFA",
     }
 }
 
@@ -1113,7 +1134,7 @@ mod tests {
     #[test]
     fn test_provider_id_all() {
         let all = ProviderId::all();
-        assert_eq!(all.len(), 79);
+        assert_eq!(all.len(), 82);
         assert!(all.contains(&ProviderId::Claude));
         assert!(all.contains(&ProviderId::Codex));
         assert!(all.contains(&ProviderId::Pi));
@@ -1173,6 +1194,9 @@ mod tests {
         assert!(all.contains(&ProviderId::Replicate));
         assert!(all.contains(&ProviderId::Muse));
         assert!(all.contains(&ProviderId::Nous));
+        assert!(all.contains(&ProviderId::Hyper));
+        assert!(all.contains(&ProviderId::GitKraken));
+        assert!(all.contains(&ProviderId::Bifrost));
     }
 
     #[test]
diff --git a/rust/src/core/provider_factory.rs b/rust/src/core/provider_factory.rs
index d801961af9..747763d4be 100644
--- a/rust/src/core/provider_factory.rs
+++ b/rust/src/core/provider_factory.rs
@@ -8,21 +8,21 @@
 use super::{Provider, ProviderId};
 use crate::providers::{
     AbacusProvider, AiAndProvider, AlibabaProvider, AlibabaTokenPlanProvider, AmpProvider,
-    AntigravityProvider, AugmentProvider, AzureOpenAIProvider, BedrockProvider, ChutesProvider,
-    ClaudeProvider, ClinePassProvider, CodeBuddyProvider, CodeRabbitProvider, CodebuffProvider,
-    CodexProvider, CommandCodeProvider, CopilotProvider, CrossModelProvider, CursorProvider,
-    DeepInfraProvider, DeepSeekProvider, DeepgramProvider, DevinProvider, DoubaoProvider,
-    ElevenLabsProvider, FactoryProvider, FireworksProvider, GeminiProvider, GrokProvider,
-    GroqProvider, HelmcodeProvider, HuggingFaceProvider, InfiniProvider, JetBrainsProvider,
-    KiloProvider, KimiK2Provider, KimiProvider, KiroProvider, LLMProxyProvider, LiteLLMProvider,
-    LongCatProvider, ManusProvider, MetaProvider, MiMoProvider, MiniMaxProvider, MistralProvider,
-    MuseProvider, NanoGPTProvider, NeuralwattProvider, NotionProvider, NousProvider,
-    OllamaProvider, OpenAIApiProvider, OpenCodeGoProvider, OpenCodeProvider, OpenRouterProvider,
-    PerplexityProvider, PiProvider, PoeProvider, QoderProvider, QwenCloudProvider,
-    ReplicateProvider, SakanaProvider, StepFunProvider, Sub2ApiProvider, T3ChatProvider,
-    TypeSafeProvider, V0Provider, VeniceProvider, VertexAIProvider, WarpProvider,
-    WayfinderProvider, WindsurfProvider, XaiProvider, ZaiProvider, ZedProvider, ZenMuxProvider,
-    ZoomMateProvider,
+    AntigravityProvider, AugmentProvider, AzureOpenAIProvider, BedrockProvider, BifrostProvider,
+    ChutesProvider, ClaudeProvider, ClinePassProvider, CodeBuddyProvider, CodeRabbitProvider,
+    CodebuffProvider, CodexProvider, CommandCodeProvider, CopilotProvider, CrossModelProvider,
+    CursorProvider, DeepInfraProvider, DeepSeekProvider, DeepgramProvider, DevinProvider,
+    DoubaoProvider, ElevenLabsProvider, FactoryProvider, FireworksProvider, GeminiProvider,
+    GitKrakenProvider, GrokProvider, GroqProvider, HelmcodeProvider, HuggingFaceProvider,
+    HyperProvider, InfiniProvider, JetBrainsProvider, KiloProvider, KimiK2Provider, KimiProvider,
+    KiroProvider, LLMProxyProvider, LiteLLMProvider, LongCatProvider, ManusProvider, MetaProvider,
+    MiMoProvider, MiniMaxProvider, MistralProvider, MuseProvider, NanoGPTProvider,
+    NeuralwattProvider, NotionProvider, NousProvider, OllamaProvider, OpenAIApiProvider,
+    OpenCodeGoProvider, OpenCodeProvider, OpenRouterProvider, PerplexityProvider, PiProvider,
+    PoeProvider, QoderProvider, QwenCloudProvider, ReplicateProvider, SakanaProvider,
+    StepFunProvider, Sub2ApiProvider, T3ChatProvider, TypeSafeProvider, V0Provider, VeniceProvider,
+    VertexAIProvider, WarpProvider, WayfinderProvider, WindsurfProvider, XaiProvider, ZaiProvider,
+    ZedProvider, ZenMuxProvider, ZoomMateProvider,
 };
 
 /// Instantiate the concrete [`Provider`] implementation for a given [`ProviderId`].
@@ -110,6 +110,9 @@ pub fn instantiate(id: ProviderId) -> Box<dyn Provider> {
         ProviderId::Meta => Box::new(MetaProvider::new()),
         ProviderId::Muse => Box::new(MuseProvider::new()),
         ProviderId::Nous => Box::new(NousProvider::new()),
+        ProviderId::Hyper => Box::new(HyperProvider::new()),
+        ProviderId::GitKraken => Box::new(GitKrakenProvider::new()),
+        ProviderId::Bifrost => Box::new(BifrostProvider::new()),
     }
 }
 
diff --git a/rust/src/core/token_accounts.rs b/rust/src/core/token_accounts.rs
index dbbb929d83..2b86ad8181 100755
--- a/rust/src/core/token_accounts.rs
+++ b/rust/src/core/token_accounts.rs
@@ -376,7 +376,10 @@ impl TokenAccountSupport {
             | ProviderId::Fireworks
             | ProviderId::Meta
             | ProviderId::Nous
-            | ProviderId::Muse => None,
+            | ProviderId::Muse
+            | ProviderId::Hyper
+            | ProviderId::GitKraken
+            | ProviderId::Bifrost => None,
         }
     }
 
@@ -795,6 +798,9 @@ mod tests {
         assert!(TokenAccountSupport::is_supported(ProviderId::Grok));
         assert!(!TokenAccountSupport::is_supported(ProviderId::Codex));
         assert!(!TokenAccountSupport::is_supported(ProviderId::Gemini));
+        assert!(!TokenAccountSupport::is_supported(ProviderId::Hyper));
+        assert!(!TokenAccountSupport::is_supported(ProviderId::GitKraken));
+        assert!(!TokenAccountSupport::is_supported(ProviderId::Bifrost));
     }
 
     #[test]
diff --git a/rust/src/providers/bifrost/mod.rs b/rust/src/providers/bifrost/mod.rs
new file mode 100644
index 0000000000..d872103c12
--- /dev/null
+++ b/rust/src/providers/bifrost/mod.rs
@@ -0,0 +1,1037 @@
+//! Bifrost self-hosted gateway quotas and model spend.
+//!
+//! Ported from upstream CodexBar v0.65.0. The configured gateway URL is
+//! validated before resolving or attaching the virtual-key credential.
+
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use reqwest::{Client, StatusCode, Url};
+use serde_json::Value;
+use std::{net::IpAddr, time::Duration};
+
+use crate::core::{
+    CostSnapshot, FetchContext, Provider, ProviderDisplayDetail, ProviderError,
+    ProviderFetchResult, ProviderId, ProviderMetadata, RateWindow, SourceMode, UsageSnapshot,
+};
+
+const CREDENTIAL_TARGET: &str = "codexbar-bifrost";
+const API_KEY_ENV: &str = "BIFROST_API_KEY";
+const REQUEST_TIMEOUT: Duration = Duration::from_secs(15);
+const MAX_RESPONSE_BYTES: usize = 2 * 1024 * 1024;
+const QUOTA_PATH: &str = "/api/governance/virtual-keys/quota";
+
+pub struct BifrostProvider {
+    metadata: ProviderMetadata,
+    client: Option<Client>,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+struct Scope {
+    id: String,
+    title: Option<String>,
+    body: Value,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+struct Budget {
+    id: String,
+    scope: Scope,
+    source: Option<String>,
+    used: f64,
+    usage_known: bool,
+    limit: f64,
+    reset: ResetTiming,
+    models: Vec<Value>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+struct ResetTiming {
+    seconds: Option<f64>,
+    window_minutes: Option<u32>,
+    resets_at: Option<DateTime<Utc>>,
+    label: Option<&'static str>,
+}
+
+impl BifrostProvider {
+    pub fn new() -> Self {
+        Self {
+            metadata: ProviderMetadata {
+                id: ProviderId::Bifrost,
+                display_name: "Bifrost",
+                session_label: "Budget",
+                weekly_label: "Spend",
+                supports_opus: false,
+                supports_credits: true,
+                default_enabled: false,
+                is_primary: false,
+                dashboard_url: None,
+                status_page_url: None,
+                tertiary_label_key: None,
+            },
+            client: crate::core::credentialed_http_client_builder()
+                .timeout(REQUEST_TIMEOUT)
+                // The virtual-key credential uses a custom header; never
+                // follow a gateway redirect that could forward it elsewhere.
+                .redirect(reqwest::redirect::Policy::none())
+                .build()
+                .ok(),
+        }
+    }
+
+    async fn fetch_api(&self, ctx: &FetchContext) -> Result<ProviderFetchResult, ProviderError> {
+        // Validate before touching the keyring/environment or constructing a
+        // request. A malformed/custom public HTTP endpoint must never receive
+        // the virtual-key secret.
+        let base = ctx
+            .gateway_url
+            .clone()
+            .or_else(|| std::env::var("BIFROST_BASE_URL").ok())
+            .ok_or_else(|| {
+                ProviderError::NotInstalled(
+                    "Bifrost gateway URL not found. Set it in provider settings or BIFROST_BASE_URL."
+                        .into(),
+                )
+            })?;
+        let url = quota_url(&base)?;
+        let api_key = crate::providers::resolve_api_key(
+            ctx.api_key.as_deref(),
+            CREDENTIAL_TARGET,
+            &[API_KEY_ENV],
+        )?;
+        let client = self.client.as_ref().ok_or_else(|| {
+            ProviderError::Other("Could not create a secure Bifrost HTTP client.".into())
+        })?;
+
+        let timeout = Duration::from_secs(ctx.web_timeout.max(1)).min(REQUEST_TIMEOUT);
+        let response = client
+            .get(url)
+            .header("x-bf-vk", api_key)
+            .header("Accept", "application/json")
+            .timeout(timeout)
+            .send()
+            .await?;
+        let status = response.status();
+        match status {
+            StatusCode::UNAUTHORIZED => return Err(ProviderError::AuthRequired),
+            StatusCode::FORBIDDEN => {
+                return Err(ProviderError::Other(
+                    "Bifrost denied access to this virtual key's quota.".into(),
+                ));
+            }
+            StatusCode::TOO_MANY_REQUESTS => {
+                return Err(ProviderError::Other(
+                    "Bifrost quota request was rate limited (HTTP 429).".into(),
+                ));
+            }
+            status if status.is_server_error() => {
+                return Err(ProviderError::Other(format!(
+                    "Bifrost quota service is unavailable (HTTP {status})."
+                )));
+            }
+            status if !status.is_success() => {
+                return Err(ProviderError::Other(format!(
+                    "Bifrost quota request failed (HTTP {status})."
+                )));
+            }
+            _ => {}
+        }
+
+        let bytes = crate::providers::read_bounded_response(response, MAX_RESPONSE_BYTES)
+            .await
+            .map_err(|error| match error {
+                crate::providers::BoundedBodyError::TooLarge => {
+                    ProviderError::Parse("Bifrost returned an oversized quota response.".into())
+                }
+                crate::providers::BoundedBodyError::Read(error) => ProviderError::Network(error),
+            })?;
+        let body = std::str::from_utf8(&bytes)
+            .map_err(|_| ProviderError::Parse("Bifrost returned non-UTF-8 quota data.".into()))?;
+        let value: Value = serde_json::from_str(body)
+            .map_err(|_| ProviderError::Parse("Bifrost returned invalid quota JSON.".into()))?;
+        let parsed = parse_usage(&value, Utc::now())?;
+        Ok(result_from_usage(parsed))
+    }
+}
+
+impl Default for BifrostProvider {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait]
+impl Provider for BifrostProvider {
+    fn id(&self) -> ProviderId {
+        ProviderId::Bifrost
+    }
+
+    fn metadata(&self) -> &ProviderMetadata {
+        &self.metadata
+    }
+
+    async fn fetch_usage(&self, ctx: &FetchContext) -> Result<ProviderFetchResult, ProviderError> {
+        match ctx.source_mode {
+            SourceMode::Auto | SourceMode::OAuth => self.fetch_api(ctx).await,
+            source => Err(ProviderError::UnsupportedSource(source)),
+        }
+    }
+
+    fn available_sources(&self) -> Vec<SourceMode> {
+        vec![SourceMode::Auto, SourceMode::OAuth]
+    }
+}
+
+fn quota_url(raw: &str) -> Result<Url, ProviderError> {
+    let raw = raw.trim();
+    if raw.is_empty() {
+        return Err(ProviderError::Other("Bifrost gateway URL is empty.".into()));
+    }
+    let candidate = if raw.contains("://") {
+        raw.to_owned()
+    } else {
+        format!("https://{raw}")
+    };
+    let mut url = Url::parse(&candidate)
+        .map_err(|_| ProviderError::Other("Bifrost gateway URL is invalid.".into()))?;
+    let host = url
+        .host_str()
+        .ok_or_else(|| ProviderError::Other("Bifrost gateway URL must include a host.".into()))?;
+    if !url.username().is_empty() || url.password().is_some() || url.fragment().is_some() {
+        return Err(ProviderError::Other(
+            "Bifrost gateway URL cannot contain user information or a fragment.".into(),
+        ));
+    }
+    let allowed = match url.scheme() {
+        "https" => true,
+        "http" => is_private_http_host(host),
+        _ => false,
+    };
+    if !allowed {
+        return Err(ProviderError::Other(
+            "Bifrost gateway must use HTTPS; HTTP is allowed only for private or loopback IP addresses.".into(),
+        ));
+    }
+
+    // Treat the configured value as a base, preserving a configured path and
+    // query while replacing any trailing slash with the documented API route.
+    let query = url.query().map(str::to_owned);
+    let path = format!("{}{}", url.path().trim_end_matches('/'), QUOTA_PATH);
+    url.set_path(&path);
+    url.set_query(query.as_deref());
+    Ok(url)
+}
+
+/// Validate a configured gateway URL before saving it to settings.
+pub fn validate_gateway_url(raw: &str) -> Result<(), ProviderError> {
+    quota_url(raw).map(|_| ())
+}
+
+fn is_private_http_host(host: &str) -> bool {
+    if host.eq_ignore_ascii_case("localhost") || host.ends_with(".localhost") {
+        return true;
+    }
+    let host = host.trim_start_matches('[').trim_end_matches(']');
+    let Ok(ip) = host.parse::<IpAddr>() else {
+        return false;
+    };
+    match ip {
+        IpAddr::V4(ip) => ip.is_private() || ip.is_loopback() || ip.is_link_local(),
+        IpAddr::V6(ip) => {
+            ip.is_loopback() || ip.is_unique_local() || (ip.segments()[0] & 0xffc0) == 0xfe80
+        }
+    }
+}
+
+fn parse_usage(value: &Value, now: DateTime<Utc>) -> Result<ParsedUsage, ProviderError> {
+    object(value, "quota response")?;
+    let active = optional_bool(value, "is_active")?;
+    let mut scopes = vec![Scope {
+        id: String::new(),
+        title: None,
+        body: value.clone(),
+    }];
+    add_scopes(
+        &mut scopes,
+        value,
+        "provider_configs",
+        "provider",
+        "provider-",
+    )?;
+    add_scopes(&mut scopes, value, "model_configs", "model_name", "model-")?;
+
+    let mut budgets = Vec::new();
+    let mut limits = Vec::new();
+    for scope in scopes {
+        if let Some(items) = scope.body.get("budgets") {
+            for item in array(items, "budgets")? {
+                object(item, "budget")?;
+                let id = optional_text(item, "id")?.unwrap_or_default();
+                if id.is_empty() {
+                    continue;
+                }
+                let mut limit = optional_number(item, "max_limit")?.unwrap_or(0.0);
+                let override_amount = optional_number(item, "override_amount")?.unwrap_or(0.0);
+                let override_mode = optional_text(item, "override_mode")?;
+                let cycles = optional_number(item, "override_cycles_remaining")?.unwrap_or(0.0);
+                if cycles.fract() != 0.0 {
+                    return Err(parse_error("invalid override cycles"));
+                }
+                if override_amount > 0.0
+                    && (override_mode.as_deref() == Some("forever")
+                        || (override_mode.as_deref() == Some("cycles") && cycles > 0.0))
+                {
+                    limit += override_amount;
+                }
+                if !limit.is_finite() || limit < 0.0 {
+                    return Err(parse_error("invalid effective budget"));
+                }
+                let current_usage = optional_number(item, "current_usage")?;
+                let used = current_usage.unwrap_or(0.0);
+                if used < 0.0 {
+                    return Err(parse_error("invalid current usage"));
+                }
+                let reset = reset_timing(
+                    optional_text(item, "reset_duration")?.as_deref(),
+                    optional_text(item, "last_reset")?.as_deref(),
+                    now,
+                );
+                let models = item
+                    .get("per_model_usage")
+                    .map(|v| array(v, "per_model_usage"))
+                    .transpose()?
+                    .unwrap_or_default()
+                    .to_vec();
+                budgets.push(Budget {
+                    id,
+                    scope: scope.clone(),
+                    source: optional_text(item, "source_name")?,
+                    used,
+                    usage_known: current_usage.is_some(),
+                    limit,
+                    reset,
+                    models,
+                });
+            }
+        }
+
+        // The aggregate field is a compatibility merge. It is never counted
+        // together with its component rate_limits when components are present.
+        let components = scope
+            .body
+            .get("rate_limits")
+            .map(|v| array(v, "rate_limits"))
+            .transpose()?
+            .unwrap_or_default();
+        if components.is_empty() {
+            if let Some(aggregate) = scope.body.get("rate_limit")
+                && !aggregate.is_null()
+            {
+                limits.push((scope.clone(), aggregate.clone(), 0usize));
+            }
+        } else {
+            limits.extend(
+                components
+                    .iter()
+                    .cloned()
+                    .enumerate()
+                    .map(|(index, limit)| {
+                        object(&limit, "rate limit")?;
+                        Ok((scope.clone(), limit, index))
+                    })
+                    .collect::<Result<Vec<_>, ProviderError>>()?,
+            );
+        }
+    }
+    budgets.sort_by(|a, b| {
+        a.reset
+            .seconds
+            .unwrap_or(f64::INFINITY)
+            .total_cmp(&b.reset.seconds.unwrap_or(f64::INFINITY))
+            .then_with(|| a.id.cmp(&b.id))
+    });
+    if active == Some(false) && budgets.is_empty() && limits.is_empty() {
+        return Err(ProviderError::Other(
+            "Bifrost virtual key is inactive and has no budgets or rate limits to display.".into(),
+        ));
+    }
+    Ok(ParsedUsage {
+        active,
+        budgets,
+        limits,
+    })
+}
+
+#[derive(Debug, Clone, PartialEq)]
+struct ParsedUsage {
+    active: Option<bool>,
+    budgets: Vec<Budget>,
+    limits: Vec<(Scope, Value, usize)>,
+}
+
+fn add_scopes(
+    scopes: &mut Vec<Scope>,
+    root: &Value,
+    collection: &str,
+    label_field: &str,
+    prefix: &str,
+) -> Result<(), ProviderError> {
+    let Some(value) = root.get(collection) else {
+        return Ok(());
+    };
+    for (index, body) in array(value, collection)?.iter().enumerate() {
+        let provider = optional_text(body, "provider")?;
+        let model = optional_text(body, label_field)?;
+        let title = if label_field == "model_name" {
+            Some(format!(
+                "Model {}",
+                [provider, model.or_else(|| Some((index + 1).to_string()))]
+                    .into_iter()
+                    .flatten()
+                    .collect::<Vec<_>>()
+                    .join(" · ")
+            ))
+        } else {
+            Some(format!(
+                "Provider {}",
+                provider.unwrap_or_else(|| (index + 1).to_string())
+            ))
+        };
+        scopes.push(Scope {
+            id: format!("{prefix}{index}-"),
+            title,
+            body: body.clone(),
+        });
+    }
+    Ok(())
+}
+
+fn result_from_usage(usage: ParsedUsage) -> ProviderFetchResult {
+    let mut budget_windows = usage
+        .budgets
+        .iter()
+        .filter(|budget| budget.limit > 0.0)
+        .map(|budget| {
+            let title = bounded(
+                &[
+                    budget.scope.title.as_deref(),
+                    Some(budget.source.as_deref().unwrap_or("Budget")),
+                ]
+                .into_iter()
+                .flatten()
+                .collect::<Vec<_>>()
+                .join(" · "),
+            );
+            let window = RateWindow::with_details(
+                percent(budget.used, budget.limit),
+                budget.reset.window_minutes,
+                budget.reset.resets_at,
+                Some(budget_description(budget)),
+            )
+            .with_usage_known(budget.usage_known);
+            (budget, title, window)
+        })
+        .collect::<Vec<_>>();
+    let root_windows = budget_windows
+        .iter()
+        .filter(|(budget, _, _)| budget.scope.id.is_empty())
+        .collect::<Vec<_>>();
+    let primary = root_windows
+        .first()
+        .map(|(_, _, window)| window.clone())
+        .unwrap_or_else(|| RateWindow::informational("No Bifrost budget quota reported"));
+    let secondary = root_windows.get(1).map(|(_, _, window)| (*window).clone());
+    let mut snapshot = UsageSnapshot::new(primary).with_login_method("API");
+    if let Some(secondary) = secondary {
+        snapshot = snapshot.with_secondary(secondary);
+    }
+    let mut extra_windows = root_windows
+        .iter()
+        .skip(2)
+        .map(|(_, title, window)| {
+            (
+                format!(
+                    "bifrost-budget-{}",
+                    window.reset_description.as_deref().unwrap_or("extra")
+                ),
+                title.clone(),
+                window.clone(),
+            )
+        })
+        .collect::<Vec<_>>();
+    extra_windows.extend(
+        budget_windows
+            .drain(..)
+            .filter(|(budget, _, _)| !budget.scope.id.is_empty())
+            .map(|(budget, title, window)| {
+                (
+                    format!("bifrost-{}budget-{}", budget.scope.id, budget.id),
+                    title,
+                    window,
+                )
+            }),
+    );
+
+    for (scope, limit, index) in &usage.limits {
+        let source = optional_text(limit, "source_name").ok().flatten();
+        for (key, title) in [("token", "Tokens"), ("request", "Requests")] {
+            let max = optional_number(limit, &format!("{key}_max_limit"))
+                .ok()
+                .flatten();
+            let reset_raw = optional_text(limit, &format!("{key}_reset_duration"))
+                .ok()
+                .flatten();
+            let Some(max_or_reset) = max
+                .filter(|max| *max > 0.0)
+                .or_else(|| reset_raw.as_ref().map(|_| 0.0))
+            else {
+                continue;
+            };
+            let used = optional_number(limit, &format!("{key}_current_usage"))
+                .ok()
+                .flatten()
+                .unwrap_or(0.0);
+            let reset = reset_timing(
+                reset_raw.as_deref(),
+                optional_text(limit, &format!("{key}_last_reset"))
+                    .ok()
+                    .flatten()
+                    .as_deref(),
+                Utc::now(),
+            );
+            let title = bounded(
+                &[scope.title.as_deref(), source.as_deref(), Some(title)]
+                    .into_iter()
+                    .flatten()
+                    .collect::<Vec<_>>()
+                    .join(" "),
+            );
+            let window = RateWindow::with_details(
+                if max_or_reset > 0.0 {
+                    percent(used, max_or_reset)
+                } else {
+                    0.0
+                },
+                reset.window_minutes,
+                reset.resets_at,
+                reset.label.map(str::to_owned),
+            );
+            extra_windows.push((
+                format!("bifrost-{}{}s-{index}", scope.id, key),
+                title,
+                window,
+            ));
+        }
+    }
+    for (id, title, window) in extra_windows {
+        snapshot = snapshot.with_extra_rate_window(id, title, window);
+    }
+    if usage.active == Some(false) {
+        snapshot = snapshot.with_extra_rate_window(
+            "bifrost-key-inactive",
+            "Key inactive",
+            RateWindow::informational("Virtual key is inactive"),
+        );
+    }
+
+    let mut result = ProviderFetchResult::new(snapshot, "api");
+    if let Some(first) = usage
+        .budgets
+        .iter()
+        .find(|budget| budget.scope.id.is_empty())
+    {
+        let mut cost = CostSnapshot::new(
+            first.used,
+            "USD",
+            first
+                .reset
+                .label
+                .unwrap_or(if first.limit > 0.0 { "Budget" } else { "Spend" }),
+        );
+        if first.limit > 0.0 {
+            cost = cost.with_limit(first.limit);
+        }
+        if let Some(resets_at) = first.reset.resets_at {
+            cost = cost.with_resets_at(resets_at);
+        }
+        result = result.with_cost(cost);
+    }
+
+    if usage.budgets.len() > 1 || usage.budgets.iter().any(|b| !b.scope.id.is_empty()) {
+        for (index, budget) in usage.budgets.iter().take(24).enumerate() {
+            let title = bounded(
+                &[
+                    budget.scope.title.as_deref(),
+                    Some(budget.source.as_deref().unwrap_or("Budget")),
+                ]
+                .into_iter()
+                .flatten()
+                .collect::<Vec<_>>()
+                .join(" · "),
+            );
+            let value = if budget.limit > 0.0 {
+                format!("{} / {}", usd(budget.used), usd(budget.limit))
+            } else {
+                usd(budget.used)
+            };
+            let mut detail =
+                ProviderDisplayDetail::new(format!("bifrost-budget-detail-{index}"), title, value);
+            if budget.limit > 0.0 {
+                detail =
+                    detail.and_then(|row| row.with_progress(budget.used.max(0.0), budget.limit));
+            }
+            if let Some(label) = budget.reset.label {
+                detail = detail.and_then(|row| row.with_secondary_value(label));
+            }
+            result = result.with_display_detail(detail);
+        }
+    }
+    if let Some(first) = usage
+        .budgets
+        .iter()
+        .find(|budget| budget.scope.id.is_empty())
+    {
+        let mut models = first
+            .models
+            .iter()
+            .filter_map(|model| {
+                let name = optional_text(model, "model")
+                    .ok()
+                    .flatten()
+                    .unwrap_or_else(|| "Model".into());
+                let provider = optional_text(model, "provider").ok().flatten();
+                let cost = optional_number(model, "total_cost").ok().flatten();
+                let tokens = optional_number(model, "total_tokens").ok().flatten();
+                (cost.unwrap_or(0.0) != 0.0 || tokens.unwrap_or(0.0) != 0.0)
+                    .then_some((name, provider, cost, tokens))
+            })
+            .collect::<Vec<_>>();
+        models.sort_by(|a, b| {
+            b.2.unwrap_or(0.0)
+                .total_cmp(&a.2.unwrap_or(0.0))
+                .then_with(|| b.3.unwrap_or(0.0).total_cmp(&a.3.unwrap_or(0.0)))
+                .then_with(|| a.0.cmp(&b.0))
+        });
+        for (index, (name, provider, cost, tokens)) in models.iter().take(5).enumerate() {
+            let label = bounded(
+                &[provider.as_deref(), Some(name.as_str())]
+                    .into_iter()
+                    .flatten()
+                    .collect::<Vec<_>>()
+                    .join(" · "),
+            );
+            let value = cost.map(usd).unwrap_or_else(|| "—".into());
+            let mut detail =
+                ProviderDisplayDetail::new(format!("bifrost-model-{index}"), label, value);
+            if let Some(tokens) = tokens {
+                detail = detail.and_then(|row| {
+                    row.with_secondary_value(format!("{} tokens", format_count(*tokens)))
+                });
+            }
+            result = result.with_display_detail(detail);
+        }
+        if models.len() > 5 {
+            result = result.with_display_detail(ProviderDisplayDetail::new(
+                "bifrost-model-other",
+                "Other models",
+                (models.len() - 5).to_string(),
+            ));
+        }
+    }
+    result
+}
+
+fn budget_description(budget: &Budget) -> String {
+    let mut parts = Vec::new();
+    if let Some(source) = &budget.source {
+        parts.push(bounded(&source.chars().take(24).collect::<String>()));
+    }
+    if let Some(label) = budget.reset.label {
+        parts.push(label.into());
+    }
+    parts.push(format!("{} / {}", usd(budget.used), usd(budget.limit)));
+    bounded(&parts.join(" · "))
+}
+
+fn reset_timing(reset: Option<&str>, last_reset: Option<&str>, now: DateTime<Utc>) -> ResetTiming {
+    let seconds = reset.and_then(parse_duration);
+    let fixed =
+        reset.is_some_and(|raw| !matches!(raw.chars().last(), Some('d' | 'w' | 'M' | 'Q' | 'Y')));
+    let resets_at = if fixed {
+        let start = last_reset
+            .and_then(|v| DateTime::parse_from_rfc3339(v).ok())
+            .map(|v| v.with_timezone(&Utc));
+        match (start, seconds) {
+            (Some(start), Some(seconds)) => Duration::try_from_secs_f64(seconds)
+                .ok()
+                .and_then(|period| chrono::TimeDelta::from_std(period).ok())
+                .and_then(|period| {
+                    let period_ms = period.num_milliseconds();
+                    if period_ms <= 0 {
+                        return None;
+                    }
+                    let elapsed_ms = (now - start).num_milliseconds().max(0);
+                    let periods = elapsed_ms.checked_div(period_ms)?.checked_add(1)?;
+                    let delta_ms = period_ms.checked_mul(periods)?;
+                    chrono::TimeDelta::try_milliseconds(delta_ms)
+                        .and_then(|delta| start.checked_add_signed(delta))
+                }),
+            _ => None,
+        }
+    } else {
+        None
+    };
+    let label = match reset {
+        None => None,
+        Some(raw) => match raw {
+            "1h" => Some("Hourly"),
+            "1d" => Some("Daily"),
+            "1w" => Some("Weekly"),
+            "1M" => Some("Monthly"),
+            "1Q" => Some("Quarterly"),
+            "1Y" => Some("Yearly"),
+            _ => None,
+        },
+    };
+    let minutes = seconds
+        .and_then(|value| Duration::try_from_secs_f64(value).ok())
+        .map(|duration| duration.as_secs() / 60)
+        .and_then(|minutes| u32::try_from(minutes).ok())
+        .filter(|minutes| *minutes > 0);
+    ResetTiming {
+        seconds,
+        window_minutes: (fixed).then_some(minutes).flatten(),
+        resets_at,
+        label,
+    }
+}
+
+fn parse_duration(raw: &str) -> Option<f64> {
+    let raw = raw.trim();
+    let extended = raw
+        .strip_suffix('Y')
+        .map(|n| (n, 31_536_000.0))
+        .or_else(|| raw.strip_suffix('Q').map(|n| (n, 7_776_000.0)))
+        .or_else(|| raw.strip_suffix('M').map(|n| (n, 2_592_000.0)))
+        .or_else(|| raw.strip_suffix('w').map(|n| (n, 604_800.0)))
+        .or_else(|| raw.strip_suffix('d').map(|n| (n, 86_400.0)));
+    if let Some((amount, multiplier)) = extended {
+        let seconds = amount.parse::<f64>().ok()? * multiplier;
+        return (seconds.is_finite() && seconds > 0.0).then_some(seconds);
+    }
+
+    let mut rest = raw;
+    let mut total = 0.0;
+    while !rest.is_empty() {
+        let number_end = rest
+            .find(|ch: char| !ch.is_ascii_digit() && ch != '.')
+            .unwrap_or(rest.len());
+        if number_end == 0 {
+            return None;
+        }
+        let amount = rest[..number_end].parse::<f64>().ok()?;
+        if !amount.is_finite() {
+            return None;
+        }
+        rest = &rest[number_end..];
+        let (unit, multiplier) = [
+            ("ms", 0.001),
+            ("us", 0.000_001),
+            ("µs", 0.000_001),
+            ("μs", 0.000_001),
+            ("ns", 0.000_000_001),
+            ("s", 1.0),
+            ("m", 60.0),
+            ("h", 3_600.0),
+        ]
+        .into_iter()
+        .find(|(unit, _)| rest.starts_with(unit))?;
+        total += amount * multiplier;
+        if !total.is_finite() {
+            return None;
+        }
+        rest = &rest[unit.len()..];
+    }
+    (total > 0.0).then_some(total)
+}
+
+fn quota_url_for_test(raw: &str) -> Result<Url, ProviderError> {
+    quota_url(raw)
+}
+
+fn object<'a>(
+    value: &'a Value,
+    name: &str,
+) -> Result<&'a serde_json::Map<String, Value>, ProviderError> {
+    value
+        .as_object()
+        .ok_or_else(|| parse_error(&format!("{name} must be an object")))
+}
+
+fn array<'a>(value: &'a Value, name: &str) -> Result<&'a [Value], ProviderError> {
+    match value {
+        Value::Null => Ok(&[]),
+        Value::Array(values) => Ok(values),
+        _ => Err(parse_error(&format!("{name} must be an array"))),
+    }
+}
+
+fn optional_text(value: &Value, key: &str) -> Result<Option<String>, ProviderError> {
+    match value.get(key) {
+        None | Some(Value::Null) => Ok(None),
+        Some(Value::String(value)) => {
+            Ok((!value.trim().is_empty()).then(|| value.trim().to_owned()))
+        }
+        _ => Err(parse_error(&format!("{key} must be a string"))),
+    }
+}
+
+fn optional_number(value: &Value, key: &str) -> Result<Option<f64>, ProviderError> {
+    match value.get(key) {
+        None | Some(Value::Null) => Ok(None),
+        Some(value) => value
+            .as_f64()
+            .filter(|value| value.is_finite())
+            .map(Some)
+            .ok_or_else(|| parse_error(&format!("{key} must be a finite number"))),
+    }
+}
+
+fn optional_bool(value: &Value, key: &str) -> Result<Option<bool>, ProviderError> {
+    match value.get(key) {
+        None | Some(Value::Null) => Ok(None),
+        Some(value) => value
+            .as_bool()
+            .map(Some)
+            .ok_or_else(|| parse_error(&format!("{key} must be a boolean"))),
+    }
+}
+
+fn percent(used: f64, limit: f64) -> f64 {
+    if used.is_finite() && limit.is_finite() && limit > 0.0 {
+        (used / limit * 100.0).clamp(0.0, 100.0)
+    } else {
+        0.0
+    }
+}
+
+fn usd(value: f64) -> String {
+    format!("${value:.2}")
+}
+fn bounded(value: &str) -> String {
+    value.chars().take(120).collect()
+}
+fn format_count(value: f64) -> String {
+    if value.fract() == 0.0 && value.abs() <= i64::MAX as f64 {
+        format!("{value:.0}")
+    } else {
+        format!("{value:.2}")
+    }
+}
+fn parse_error(reason: &str) -> ProviderError {
+    ProviderError::Parse(format!(
+        "Bifrost returned an unrecognized quota response ({reason})."
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+    use tokio::{
+        io::{AsyncReadExt, AsyncWriteExt},
+        net::TcpListener,
+        time::timeout,
+    };
+
+    fn now() -> DateTime<Utc> {
+        DateTime::parse_from_rfc3339("2026-01-01T00:00:00Z")
+            .unwrap()
+            .with_timezone(&Utc)
+    }
+
+    #[test]
+    fn component_rate_limits_take_precedence_over_aggregate_compatibility_field() {
+        let value = json!({
+            "rate_limit": { "token_max_limit": 900, "token_current_usage": 450, "token_reset_duration": "1h" },
+            "rate_limits": [
+                { "source_name": "provider-a", "token_max_limit": 100, "token_current_usage": 25, "token_reset_duration": "1h" },
+                { "source_name": "provider-b", "request_max_limit": 20, "request_current_usage": 5, "request_reset_duration": "1d" }
+            ]
+        });
+        let parsed = parse_usage(&value, now()).unwrap();
+        assert_eq!(parsed.limits.len(), 2);
+        assert_eq!(parsed.limits[0].1["token_max_limit"], 100);
+        assert_eq!(parsed.limits[1].1["request_max_limit"], 20);
+        assert!(
+            !parsed
+                .limits
+                .iter()
+                .any(|(_, limit, _)| limit["token_max_limit"] == 900)
+        );
+    }
+
+    #[test]
+    fn aggregate_rate_limit_is_fallback_when_components_are_absent() {
+        let parsed = parse_usage(&json!({
+            "rate_limit": { "token_max_limit": 50, "token_current_usage": 10, "token_reset_duration": "1h" }
+        }), now()).unwrap();
+        assert_eq!(parsed.limits.len(), 1);
+        assert_eq!(parsed.limits[0].1["token_max_limit"], 50);
+    }
+
+    #[test]
+    fn missing_current_usage_at_a_positive_rate_limit_is_known_zero() {
+        for (usage_field, id) in [
+            ("token_current_usage", "bifrost-tokens-0"),
+            ("request_current_usage", "bifrost-requests-0"),
+        ] {
+            let mut limit = json!({
+                "token_max_limit": 100,
+                "token_current_usage": 25,
+                "request_max_limit": 20,
+                "request_current_usage": 5
+            });
+            limit.as_object_mut().unwrap().remove(usage_field);
+            let result =
+                result_from_usage(parse_usage(&json!({ "rate_limit": limit }), now()).unwrap());
+            let named = result
+                .usage
+                .extra_rate_windows
+                .iter()
+                .find(|window| window.id == id)
+                .unwrap_or_else(|| panic!("missing named rate window {id}"));
+
+            assert_eq!(named.window.used_percent, 0.0, "{usage_field}");
+            assert!(named.usage_known, "{usage_field}");
+            assert!(named.window.usage_known(), "{usage_field}");
+        }
+    }
+
+    #[test]
+    fn validates_gateway_before_request_url_is_built() {
+        assert!(
+            quota_url_for_test("https://bifrost.example.com/base/")
+                .unwrap()
+                .as_str()
+                .starts_with("https://bifrost.example.com/base/api/governance/virtual-keys/quota")
+        );
+        assert!(quota_url_for_test("http://10.1.2.3:8080").is_ok());
+        assert!(quota_url_for_test("http://bifrost.example.com").is_err());
+        assert!(quota_url_for_test("https://user:secret@bifrost.example.com").is_err());
+        assert!(quota_url_for_test("ftp://10.1.2.3").is_err());
+    }
+
+    #[tokio::test]
+    async fn rejects_public_http_before_resolving_any_credential() {
+        let provider = BifrostProvider::new();
+        let ctx = FetchContext {
+            gateway_url: Some("http://public.example.com".into()),
+            ..FetchContext::default()
+        };
+        let error = provider.fetch_api(&ctx).await.unwrap_err();
+        assert!(error.to_string().contains("must use HTTPS"));
+    }
+
+    #[tokio::test]
+    async fn does_not_forward_virtual_key_through_gateway_redirects() {
+        let redirect_target = TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let redirect_target_addr = redirect_target.local_addr().unwrap();
+        let gateway = TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let gateway_addr = gateway.local_addr().unwrap();
+        let gateway_task = tokio::spawn(async move {
+            let (mut stream, _) = gateway.accept().await.unwrap();
+            let mut request = vec![0; 4096];
+            let read = stream.read(&mut request).await.unwrap();
+            let request = String::from_utf8_lossy(&request[..read]).to_ascii_lowercase();
+            assert!(request.contains("x-bf-vk: test-virtual-key"));
+            let response = format!(
+                "HTTP/1.1 302 Found\r\nLocation: http://{redirect_target_addr}/redirected\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
+            );
+            stream.write_all(response.as_bytes()).await.unwrap();
+        });
+        let redirect_target_task = tokio::spawn(async move {
+            timeout(Duration::from_millis(250), redirect_target.accept()).await
+        });
+
+        let provider = BifrostProvider::new();
+        let ctx = FetchContext {
+            gateway_url: Some(format!("http://{gateway_addr}")),
+            api_key: Some("test-virtual-key".into()),
+            ..FetchContext::default()
+        };
+        let error = provider.fetch_api(&ctx).await.unwrap_err();
+        assert!(error.to_string().contains("HTTP 302"));
+        gateway_task.await.unwrap();
+        assert!(redirect_target_task.await.unwrap().is_err());
+    }
+
+    #[test]
+    fn parses_fixed_reset_and_calendar_label_without_inventing_calendar_time() {
+        let fixed = reset_timing(Some("1h"), Some("2025-12-31T23:30:00Z"), now());
+        assert_eq!(fixed.window_minutes, Some(60));
+        assert_eq!(
+            fixed.resets_at.unwrap().to_rfc3339(),
+            "2026-01-01T00:30:00+00:00"
+        );
+        let calendar = reset_timing(Some("1M"), Some("2025-12-01T00:00:00Z"), now());
+        assert_eq!(calendar.label, Some("Monthly"));
+        assert_eq!(calendar.resets_at, None);
+        assert_eq!(calendar.window_minutes, None);
+        assert_eq!(parse_duration("1h30m"), Some(5_400.0));
+    }
+
+    #[test]
+    fn budgets_and_overrides_are_mapped_to_percent_and_spend() {
+        let parsed = parse_usage(
+            &json!({
+                "virtual_key_name": "Build key",
+                "budgets": [{ "id": "b1", "max_limit": 10, "current_usage": 5,
+                    "override_amount": 5, "override_mode": "forever", "source_name": "Team" }]
+            }),
+            now(),
+        )
+        .unwrap();
+        let result = result_from_usage(parsed);
+        assert!((result.usage.primary.used_percent - (100.0 / 3.0)).abs() < 0.001);
+        assert_eq!(result.cost.unwrap().limit, Some(15.0));
+    }
+
+    #[test]
+    fn shortest_root_budget_is_primary_and_cost_without_summing_budgets() {
+        let parsed = parse_usage(
+            &json!({
+                "budgets": [
+                    { "id": "monthly", "max_limit": 1_000, "current_usage": 200,
+                        "reset_duration": "1M" },
+                    { "id": "daily", "max_limit": 100, "current_usage": 10,
+                        "reset_duration": "1d" }
+                ]
+            }),
+            now(),
+        )
+        .unwrap();
+        let result = result_from_usage(parsed);
+
+        assert_eq!(result.usage.primary.used_percent, 10.0);
+        assert_eq!(
+            result.usage.primary.reset_description.as_deref(),
+            Some("Daily · $10.00 / $100.00")
+        );
+        let secondary = result.usage.secondary.as_ref().unwrap();
+        assert_eq!(secondary.used_percent, 20.0);
+        assert_eq!(
+            secondary.reset_description.as_deref(),
+            Some("Monthly · $200.00 / $1000.00")
+        );
+
+        let cost = result.cost.unwrap();
+        assert_eq!(cost.used, 10.0);
+        assert_eq!(cost.limit, Some(100.0));
+        assert_eq!(cost.period, "Daily");
+    }
+
+    #[test]
+    fn malformed_optional_scope_collection_fails_closed() {
+        assert!(parse_usage(&json!({ "provider_configs": {} }), now()).is_err());
+    }
+}
diff --git a/rust/src/providers/gitkraken/mod.rs b/rust/src/providers/gitkraken/mod.rs
new file mode 100644
index 0000000000..5ff37f765d
--- /dev/null
+++ b/rust/src/providers/gitkraken/mod.rs
@@ -0,0 +1,615 @@
+//! GitKraken AI usage provider.
+//!
+//! The API returns personal credits and, when an organization is selected,
+//! its shared-pool total. Shared usage is a slice of that total and is only
+//! exposed as display detail; it must not be added to personal usage.
+
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use reqwest::StatusCode;
+use serde_json::Value;
+use std::time::Duration;
+
+use crate::core::{
+    FetchContext, Provider, ProviderDisplayDetail, ProviderError, ProviderFetchResult, ProviderId,
+    ProviderMetadata, RateWindow, SourceMode, UsageSnapshot,
+};
+use crate::providers::{BoundedBodyError, read_bounded_response};
+
+const USAGE_URL: &str = "https://api.gitkraken.dev/v1/ai-tasks/usage";
+const CREDENTIAL_TARGET: &str = "codexbar-gitkraken";
+const TOKEN_ENV: &str = "GITKRAKEN_API_TOKEN";
+const ORGANIZATION_ENV: &str = "GITKRAKEN_ORG_ID";
+const REQUEST_TIMEOUT: Duration = Duration::from_secs(15);
+const MAX_RESPONSE_BYTES: usize = 64 * 1024;
+const WEEKLY_WINDOW_MINUTES: u32 = 10_080;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+struct Quota {
+    used: f64,
+    limit: f64,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+struct GitKrakenUsage {
+    personal: Quota,
+    organization: Option<Quota>,
+    shared_used: Option<f64>,
+    resets_at: DateTime<Utc>,
+}
+
+/// GitKraken AI provider.
+pub struct GitKrakenProvider {
+    metadata: ProviderMetadata,
+}
+
+impl GitKrakenProvider {
+    pub fn new() -> Self {
+        Self {
+            metadata: ProviderMetadata {
+                id: ProviderId::GitKraken,
+                display_name: "GitKraken AI",
+                session_label: "Personal",
+                weekly_label: "Shared pool",
+                supports_opus: false,
+                supports_credits: false,
+                default_enabled: false,
+                is_primary: false,
+                dashboard_url: Some("https://gitkraken.dev/account#ai-usage"),
+                status_page_url: None,
+                tertiary_label_key: None,
+            },
+        }
+    }
+
+    async fn fetch(&self, ctx: &FetchContext) -> Result<ProviderFetchResult, ProviderError> {
+        self.fetch_from(ctx, USAGE_URL).await
+    }
+
+    async fn fetch_from(
+        &self,
+        ctx: &FetchContext,
+        usage_url: &str,
+    ) -> Result<ProviderFetchResult, ProviderError> {
+        let token = resolve_token(ctx.api_key.as_deref())?;
+        let organization = resolve_organization(ctx.workspace_id.as_deref())?;
+        let client = crate::core::credentialed_http_client_builder()
+            .timeout(REQUEST_TIMEOUT)
+            .build()
+            .map_err(|error| {
+                ProviderError::Other(format!("Could not create GitKraken client: {error}"))
+            })?;
+
+        let mut request = client
+            .get(usage_url)
+            .bearer_auth(token)
+            .header("Client-Name", "CodexBar")
+            .header("Client-Version", env!("CARGO_PKG_VERSION"))
+            .header("User-Agent", "CodexBar");
+        if let Some(organization) = organization.as_deref() {
+            request = request.header("gk-org-id", organization);
+        }
+
+        let response = request.send().await?;
+        let status = response.status();
+        if status != StatusCode::OK {
+            return Err(status_error(status));
+        }
+
+        let body = read_bounded_response(response, MAX_RESPONSE_BYTES)
+            .await
+            .map_err(|error| match error {
+                BoundedBodyError::TooLarge => parse_failure("response exceeded the size limit"),
+                BoundedBodyError::Read(error) => ProviderError::Network(error),
+            })?;
+        let body = std::str::from_utf8(&body)
+            .map_err(|_| parse_failure("response was not valid UTF-8"))?;
+        let value: Value =
+            serde_json::from_str(body).map_err(|_| parse_failure("response was not valid JSON"))?;
+        let usage = parse_usage(&value)?;
+
+        Ok(result_from_usage(usage))
+    }
+}
+
+impl Default for GitKrakenProvider {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait]
+impl Provider for GitKrakenProvider {
+    fn id(&self) -> ProviderId {
+        ProviderId::GitKraken
+    }
+
+    fn metadata(&self) -> &ProviderMetadata {
+        &self.metadata
+    }
+
+    async fn fetch_usage(&self, ctx: &FetchContext) -> Result<ProviderFetchResult, ProviderError> {
+        match ctx.source_mode {
+            SourceMode::Auto | SourceMode::OAuth => self.fetch(ctx).await,
+            source => Err(ProviderError::UnsupportedSource(source)),
+        }
+    }
+
+    fn available_sources(&self) -> Vec<SourceMode> {
+        vec![SourceMode::Auto, SourceMode::OAuth]
+    }
+}
+
+fn resolve_token(configured: Option<&str>) -> Result<String, ProviderError> {
+    let keyring_token = keyring::Entry::new(CREDENTIAL_TARGET, "api_token")
+        .ok()
+        .and_then(|entry| entry.get_password().ok());
+    let token = configured
+        .filter(|token| !token.trim().is_empty())
+        .map(str::to_string)
+        .or(keyring_token)
+        .or_else(|| std::env::var(TOKEN_ENV).ok())
+        .unwrap_or_default();
+    let token = token.trim();
+    if token.is_empty() {
+        return Err(ProviderError::NotInstalled(format!(
+            "Set a GitKraken access token in Settings or {TOKEN_ENV}."
+        )));
+    }
+    if token.len() > 16_384 || !token.bytes().all(|byte| (0x21..=0x7e).contains(&byte)) {
+        return Err(ProviderError::AuthRequired);
+    }
+    Ok(token.to_string())
+}
+
+fn resolve_organization(configured: Option<&str>) -> Result<Option<String>, ProviderError> {
+    let organization = configured
+        .map(str::to_string)
+        .or_else(|| std::env::var(ORGANIZATION_ENV).ok())
+        .unwrap_or_default();
+    let organization = organization.trim();
+    if organization.is_empty() {
+        return Ok(None);
+    }
+    if organization.len() > 256
+        || !organization
+            .bytes()
+            .all(|byte| (0x21..=0x7e).contains(&byte))
+    {
+        return Err(ProviderError::Other(
+            "Invalid GitKraken organization ID. Enter a single ID without whitespace.".into(),
+        ));
+    }
+    Ok(Some(organization.to_string()))
+}
+
+fn status_error(status: StatusCode) -> ProviderError {
+    match status {
+        StatusCode::UNAUTHORIZED => ProviderError::AuthRequired,
+        StatusCode::FORBIDDEN => {
+            ProviderError::Other("GitKraken denied access to this account or organization.".into())
+        }
+        StatusCode::TOO_MANY_REQUESTS => {
+            ProviderError::Other("GitKraken rate limited usage requests.".into())
+        }
+        status if status.is_server_error() => {
+            ProviderError::Other("GitKraken usage is temporarily unavailable.".into())
+        }
+        _ => ProviderError::Other(format!("GitKraken returned HTTP {status}.")),
+    }
+}
+
+fn parse_usage(body: &Value) -> Result<GitKrakenUsage, ProviderError> {
+    let data = body
+        .get("data")
+        .and_then(Value::as_object)
+        .ok_or_else(|| parse_failure("missing data object"))?;
+    if body.get("error").is_some_and(|error| !error.is_null()) {
+        return Err(parse_failure("API returned an error envelope"));
+    }
+
+    let personal = parse_quota(&Value::Object(data.clone()))
+        .ok_or_else(|| parse_failure("invalid personal quota"))?;
+    let resets_at = data
+        .get("resetsOn")
+        .and_then(Value::as_str)
+        .and_then(|value| DateTime::parse_from_rfc3339(value).ok())
+        .map(|value| value.with_timezone(&Utc))
+        .ok_or_else(|| parse_failure("invalid reset timestamp"))?;
+
+    // Upstream deliberately ignores a malformed optional organization quota
+    // without discarding the valid personal quota.
+    let organization = data.get("organization").and_then(parse_quota);
+    let shared_used = data
+        .get("sharedUsed")
+        .and_then(Value::as_f64)
+        .filter(|value| value.is_finite() && *value >= 0.0)
+        .filter(|value| organization.is_some_and(|pool| *value <= pool.used));
+
+    Ok(GitKrakenUsage {
+        personal,
+        organization,
+        shared_used,
+        resets_at,
+    })
+}
+
+fn parse_quota(value: &Value) -> Option<Quota> {
+    let object = value.as_object()?;
+    let used = object.get("used")?.as_f64()?;
+    let limit = object.get("limit")?.as_f64()?;
+    (used.is_finite()
+        && used >= 0.0
+        && limit.is_finite()
+        && (limit >= 0.0 || limit == -1.0)
+        && (limit <= 0.0 || ((used / limit) * 100.0).is_finite()))
+    .then_some(Quota { used, limit })
+}
+
+fn result_from_usage(usage: GitKrakenUsage) -> ProviderFetchResult {
+    let personal = usage.personal;
+    let primary = rate_window(personal, usage.resets_at)
+        .unwrap_or_else(|| RateWindow::informational(quota_description(personal)));
+    let mut snapshot = UsageSnapshot::new(primary)
+        .with_primary_label("Personal")
+        .with_login_method("API");
+    if let Some(pool) = usage.organization
+        && let Some(window) = rate_window(pool, usage.resets_at)
+    {
+        snapshot = snapshot
+            .with_secondary(window)
+            .with_secondary_label("Shared pool");
+    }
+
+    let mut result = ProviderFetchResult::new(snapshot, "api").with_display_detail(
+        ProviderDisplayDetail::new("personal-credits", "Personal", quota_description(personal)),
+    );
+    if let Some(pool) = usage.organization {
+        result = result.with_display_detail(ProviderDisplayDetail::new(
+            "shared-pool-credits",
+            "Shared pool",
+            quota_description(pool),
+        ));
+        if let Some(shared_used) = usage.shared_used {
+            result = result
+                .with_display_detail(ProviderDisplayDetail::new(
+                    "your-shared-usage",
+                    "Your shared usage",
+                    format!("{} credits", format_number(shared_used)),
+                ))
+                .with_display_detail(ProviderDisplayDetail::new(
+                    "organization-rest-usage",
+                    "Rest of organization",
+                    format!("{} credits", format_number(pool.used - shared_used)),
+                ));
+        }
+    }
+    if personal.limit <= 0.0 && usage.organization.is_none_or(|pool| pool.limit <= 0.0) {
+        result = result.with_display_detail(ProviderDisplayDetail::new(
+            "reset",
+            "Reset",
+            usage.resets_at.to_rfc3339(),
+        ));
+    }
+    result
+}
+
+fn rate_window(quota: Quota, resets_at: DateTime<Utc>) -> Option<RateWindow> {
+    (quota.limit > 0.0).then(|| {
+        RateWindow::with_details(
+            (quota.used / quota.limit) * 100.0,
+            Some(WEEKLY_WINDOW_MINUTES),
+            Some(resets_at),
+            None,
+        )
+    })
+}
+
+fn quota_description(quota: Quota) -> String {
+    if quota.limit <= 0.0 {
+        format!(
+            "{} credits used · {}",
+            format_number(quota.used),
+            if quota.limit == -1.0 {
+                "Unlimited"
+            } else {
+                "No allowance"
+            }
+        )
+    } else {
+        format!(
+            "{} / {} credits used",
+            format_number(quota.used),
+            format_number(quota.limit)
+        )
+    }
+}
+
+fn format_number(value: f64) -> String {
+    let rounded = if value.abs() <= f64::MAX / 100.0 {
+        (value * 100.0).round() / 100.0
+    } else {
+        value
+    };
+    let fixed = format!("{rounded:.2}");
+    let trimmed = fixed.trim_end_matches('0').trim_end_matches('.');
+    let (integer, fraction) = trimmed.split_once('.').unwrap_or((trimmed, ""));
+    let mut grouped = String::with_capacity(trimmed.len() + integer.len() / 3);
+    for (index, digit) in integer.chars().enumerate() {
+        if index > 0 && (integer.len() - index) % 3 == 0 {
+            grouped.push(',');
+        }
+        grouped.push(digit);
+    }
+    if !fraction.is_empty() {
+        grouped.push('.');
+        grouped.push_str(fraction);
+    }
+    grouped
+}
+
+fn parse_failure(reason: &str) -> ProviderError {
+    ProviderError::Parse(format!(
+        "GitKraken returned an unrecognized usage response ({reason})."
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+    use tokio::{
+        io::{AsyncReadExt, AsyncWriteExt},
+        net::TcpListener,
+    };
+
+    fn response(personal_limit: Value, organization: Value, shared_used: Value) -> Value {
+        json!({
+            "data": {
+                "used": 12_500,
+                "limit": personal_limit,
+                "resetsOn": "2026-09-27T00:00:00Z",
+                "organization": organization,
+                "sharedUsed": shared_used,
+            },
+            "error": null,
+        })
+    }
+
+    async fn assert_request_headers(organization: Option<&str>) {
+        let expected_organization = organization.map(str::to_owned);
+        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let address = listener.local_addr().unwrap();
+        let server = tokio::spawn(async move {
+            let (mut stream, _) = listener.accept().await.unwrap();
+            let mut request = Vec::new();
+            let mut chunk = [0; 1024];
+            loop {
+                let read = stream.read(&mut chunk).await.unwrap();
+                assert_ne!(read, 0, "client closed before sending HTTP headers");
+                request.extend_from_slice(&chunk[..read]);
+                if request.windows(4).any(|window| window == b"\r\n\r\n") {
+                    break;
+                }
+            }
+            let request = String::from_utf8(request).unwrap().to_ascii_lowercase();
+            assert!(request.contains("authorization: bearer fixture-token\r\n"));
+            match expected_organization.as_deref() {
+                Some(organization) => assert!(request.contains(&format!(
+                    "gk-org-id: {}\r\n",
+                    organization.to_ascii_lowercase()
+                ))),
+                None => assert!(!request.contains("gk-org-id:")),
+            }
+
+            let body =
+                r#"{"data":{"used":1,"limit":10,"resetsOn":"2026-09-27T00:00:00Z"},"error":null}"#;
+            let response = format!(
+                "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+                body.len(),
+                body
+            );
+            stream.write_all(response.as_bytes()).await.unwrap();
+        });
+
+        let ctx = FetchContext {
+            api_key: Some("fixture-token".into()),
+            workspace_id: Some(organization.unwrap_or("").into()),
+            ..FetchContext::default()
+        };
+        GitKrakenProvider::new()
+            .fetch_from(&ctx, &format!("http://{address}/usage"))
+            .await
+            .unwrap();
+        server.await.unwrap();
+    }
+
+    #[tokio::test]
+    async fn sends_bearer_token_and_optional_organization_header() {
+        assert_request_headers(Some("org-fixture")).await;
+        assert_request_headers(None).await;
+    }
+
+    #[test]
+    fn parses_personal_and_organization_weekly_quotas_with_shared_usage_as_display_only() {
+        let usage = parse_usage(&response(
+            json!(400_000),
+            json!({ "used": 20_000, "limit": 100_000 }),
+            json!(5_000),
+        ))
+        .unwrap();
+        assert_eq!(
+            usage.personal,
+            Quota {
+                used: 12_500.0,
+                limit: 400_000.0
+            }
+        );
+        assert_eq!(
+            usage.organization,
+            Some(Quota {
+                used: 20_000.0,
+                limit: 100_000.0
+            })
+        );
+        assert_eq!(usage.shared_used, Some(5_000.0));
+        assert_eq!(
+            usage.resets_at,
+            DateTime::parse_from_rfc3339("2026-09-27T00:00:00Z")
+                .unwrap()
+                .with_timezone(&Utc)
+        );
+
+        let result = result_from_usage(usage);
+        // Personal usage stays at 12,500 credits (3.125%); the shared slice
+        // is display detail and must never be added to personal usage.
+        assert_eq!(result.usage.primary.used_percent, 3.125);
+        assert_eq!(
+            result.usage.primary.window_minutes,
+            Some(WEEKLY_WINDOW_MINUTES)
+        );
+        assert_eq!(result.usage.secondary.as_ref().unwrap().used_percent, 20.0);
+        assert_eq!(
+            result
+                .display_details()
+                .iter()
+                .map(ProviderDisplayDetail::value)
+                .collect::<Vec<_>>(),
+            [
+                "12,500 / 400,000 credits used",
+                "20,000 / 100,000 credits used",
+                "5,000 credits",
+                "15,000 credits",
+            ]
+        );
+    }
+
+    #[test]
+    fn malformed_optional_organization_does_not_discard_personal_usage() {
+        for organization in [json!(null), json!({}), json!({"used":-1,"limit":100})] {
+            let usage = parse_usage(&response(json!(400_000), organization, json!(1))).unwrap();
+            assert_eq!(usage.personal.used, 12_500.0);
+            assert!(usage.organization.is_none());
+            assert!(usage.shared_used.is_none());
+        }
+    }
+
+    #[test]
+    fn invalid_shared_slice_is_ignored_without_changing_pool_total() {
+        for shared_used in [
+            json!(null),
+            json!(true),
+            json!("5"),
+            json!(-1),
+            json!(20_001),
+        ] {
+            let usage = parse_usage(&response(
+                json!(400_000),
+                json!({"used":20_000,"limit":100_000}),
+                shared_used,
+            ))
+            .unwrap();
+            assert_eq!(usage.organization.unwrap().used, 20_000.0);
+            assert!(usage.shared_used.is_none());
+        }
+    }
+
+    #[test]
+    fn zero_and_unlimited_limits_are_informational_not_fake_percentages() {
+        for (limit, expected) in [(json!(0), "No allowance"), (json!(-1), "Unlimited")] {
+            let usage = parse_usage(&response(limit, json!(null), json!(null))).unwrap();
+            let result = result_from_usage(usage);
+            assert!(result.usage.primary.is_informational);
+            assert_eq!(result.usage.primary.used_percent, 0.0);
+            assert_eq!(
+                result.display_details()[0].value(),
+                format!("12,500 credits used · {expected}")
+            );
+            assert_eq!(result.display_details().last().unwrap().title(), "Reset");
+        }
+    }
+
+    #[test]
+    fn malformed_required_personal_quota_or_reset_fails_closed() {
+        let invalid = [
+            json!({"data":{"limit":10,"resetsOn":"2026-09-27T00:00:00Z"}}),
+            json!({"data":{"used":true,"limit":10,"resetsOn":"2026-09-27T00:00:00Z"}}),
+            json!({"data":{"used":-1,"limit":10,"resetsOn":"2026-09-27T00:00:00Z"}}),
+            json!({"data":{"used":1,"limit":-0.5,"resetsOn":"2026-09-27T00:00:00Z"}}),
+            json!({"data":{"used":1,"limit":10,"resetsOn":"2026-09-27"}}),
+            json!({"data":{"used":1,"limit":10,"resetsOn":null}}),
+            json!({"error":"failure","data":{"used":1,"limit":10,"resetsOn":"2026-09-27T00:00:00Z"}}),
+        ];
+        for value in invalid {
+            assert!(matches!(parse_usage(&value), Err(ProviderError::Parse(_))));
+        }
+    }
+
+    #[test]
+    fn validates_configured_token_and_organization_values() {
+        assert_eq!(
+            resolve_token(Some(" fixture-token ")).unwrap(),
+            "fixture-token"
+        );
+        assert!(matches!(
+            resolve_token(Some("bad token")),
+            Err(ProviderError::AuthRequired)
+        ));
+        assert!(matches!(
+            resolve_token(Some("bad\ntoken")),
+            Err(ProviderError::AuthRequired)
+        ));
+        assert!(matches!(
+            resolve_token(Some(&"x".repeat(16_385))),
+            Err(ProviderError::AuthRequired)
+        ));
+
+        assert_eq!(
+            resolve_organization(Some(" org-fixture ")).unwrap(),
+            Some("org-fixture".into())
+        );
+        assert_eq!(resolve_organization(Some("  ")).unwrap(), None);
+        assert!(matches!(
+            resolve_organization(Some("org id")),
+            Err(ProviderError::Other(_))
+        ));
+        assert!(matches!(
+            resolve_organization(Some("org\nid")),
+            Err(ProviderError::Other(_))
+        ));
+        assert!(matches!(
+            resolve_organization(Some(&"x".repeat(257))),
+            Err(ProviderError::Other(_))
+        ));
+    }
+
+    #[test]
+    fn response_statuses_match_upstream_error_classes_without_reading_private_bodies() {
+        assert!(matches!(
+            status_error(StatusCode::UNAUTHORIZED),
+            ProviderError::AuthRequired
+        ));
+        assert!(matches!(
+            status_error(StatusCode::FORBIDDEN),
+            ProviderError::Other(_)
+        ));
+        assert!(matches!(
+            status_error(StatusCode::TOO_MANY_REQUESTS),
+            ProviderError::Other(_)
+        ));
+        assert!(matches!(
+            status_error(StatusCode::SERVICE_UNAVAILABLE),
+            ProviderError::Other(_)
+        ));
+        assert!(matches!(
+            status_error(StatusCode::NOT_FOUND),
+            ProviderError::Other(_)
+        ));
+    }
+
+    #[test]
+    fn formats_counts_with_at_most_two_fractional_digits() {
+        assert_eq!(format_number(12_500.0), "12,500");
+        assert_eq!(format_number(12_500.125), "12,500.13");
+    }
+}
diff --git a/rust/src/providers/hyper/mod.rs b/rust/src/providers/hyper/mod.rs
new file mode 100644
index 0000000000..c1bef93a82
--- /dev/null
+++ b/rust/src/providers/hyper/mod.rs
@@ -0,0 +1,298 @@
+//! Charm Hyper Hypercredit balance provider.
+
+use async_trait::async_trait;
+use reqwest::{Client, StatusCode, redirect::Policy};
+use serde::Deserialize;
+use std::time::Duration;
+
+use crate::core::{
+    FetchContext, Provider, ProviderDisplayDetail, ProviderError, ProviderFetchResult, ProviderId,
+    ProviderMetadata, RateWindow, SourceMode, UsageSnapshot,
+};
+use crate::providers::{BoundedBodyError, read_bounded_response};
+
+const CREDITS_URL: &str = "https://hyper.charm.land/v1/credits";
+const COOKIE_DOMAIN: &str = "hyper.charm.land";
+const CREDENTIAL_TARGET: &str = "codexbar-hyper";
+const API_KEY_ENV: &[&str] = &["HYPER_API_KEY"];
+const MAX_RESPONSE_BYTES: usize = 512 * 1024;
+const SESSION_TIMEOUT: Duration = Duration::from_secs(5);
+const API_TIMEOUT: Duration = Duration::from_secs(10);
+
+pub struct HyperProvider {
+    metadata: ProviderMetadata,
+    client: Client,
+    credits_url: String,
+}
+
+impl HyperProvider {
+    pub fn new() -> Self {
+        let client = crate::core::credentialed_http_client_builder()
+            .redirect(Policy::none())
+            .timeout(API_TIMEOUT)
+            .build()
+            .expect("Charm Hyper HTTP client configuration is valid");
+        Self::with_client(CREDITS_URL, client)
+    }
+
+    fn with_client(credits_url: impl Into<String>, client: Client) -> Self {
+        Self {
+            metadata: ProviderMetadata {
+                id: ProviderId::Hyper,
+                display_name: "Charm Hyper",
+                session_label: "Balance",
+                weekly_label: "Balance",
+                supports_opus: false,
+                supports_credits: false,
+                default_enabled: false,
+                is_primary: false,
+                dashboard_url: Some("https://hyper.charm.land"),
+                status_page_url: None,
+                tertiary_label_key: None,
+            },
+            client,
+            credits_url: credits_url.into(),
+        }
+    }
+
+    async fn fetch_balance(
+        &self,
+        key: Option<&str>,
+        cookie: Option<&str>,
+        source: &'static str,
+    ) -> Result<ProviderFetchResult, ProviderError> {
+        let mut request = self
+            .client
+            .get(&self.credits_url)
+            .header(reqwest::header::ACCEPT, "application/json")
+            .timeout(if cookie.is_some() {
+                SESSION_TIMEOUT
+            } else {
+                API_TIMEOUT
+            });
+        if let Some(cookie) = cookie {
+            request = request.header(reqwest::header::COOKIE, cookie);
+        } else if let Some(key) = key {
+            request = request.bearer_auth(key);
+        }
+
+        let response = request.send().await?;
+        let status = response.status();
+        if cookie.is_some() && is_rejected_session(status, response.headers()) {
+            return Err(ProviderError::AuthRequired);
+        }
+        if status != StatusCode::OK {
+            return Err(status_error(status));
+        }
+
+        let body = read_bounded_response(response, MAX_RESPONSE_BYTES)
+            .await
+            .map_err(|error| match error {
+                BoundedBodyError::Read(error) => ProviderError::Network(error),
+                BoundedBodyError::TooLarge => ProviderError::Parse(format!(
+                    "Charm Hyper response exceeded {MAX_RESPONSE_BYTES} bytes."
+                )),
+            })?;
+        let balance = parse_balance(&body)?;
+        let detail = ProviderDisplayDetail::new(
+            "hypercredits",
+            "Hypercredits",
+            format!("{} HC", format_balance(balance)),
+        );
+        let usage = UsageSnapshot::new(RateWindow::informational("Hypercredit balance"))
+            .with_login_method(if source == "web" {
+                "Browser session"
+            } else {
+                "API key"
+            });
+        let result = ProviderFetchResult::new(usage, source).with_display_detail(detail);
+        Ok(result)
+    }
+
+    async fn fetch_web(
+        &self,
+        ctx: &FetchContext,
+        key: Option<&str>,
+        auto_mode: bool,
+    ) -> Result<ProviderFetchResult, ProviderError> {
+        let manual_cookie = ctx
+            .manual_cookie_header
+            .as_deref()
+            .and_then(crate::providers::normalize_cookie_header);
+        let cookie = if manual_cookie.is_some() {
+            manual_cookie
+        } else if ctx.manual_cookie_header.is_some() || ctx.manual_cookie_missing {
+            None
+        } else {
+            match crate::providers::browser_cookie_header(&[COOKIE_DOMAIN]) {
+                Ok(header) => crate::providers::normalize_cookie_header(&header),
+                Err(ProviderError::NoCookies) => None,
+                Err(_) if auto_mode && key.is_some() => {
+                    tracing::debug!("Charm Hyper browser cookie lookup failed; trying API key");
+                    None
+                }
+                Err(_) => None,
+            }
+        };
+
+        if let Some(cookie) = cookie.as_deref() {
+            match self.fetch_balance(None, Some(cookie), "web").await {
+                Ok(result) => return Ok(result),
+                Err(ProviderError::AuthRequired) if auto_mode && key.is_some() => {
+                    tracing::debug!("Charm Hyper browser session was rejected; trying API key");
+                }
+                Err(ProviderError::Network(_)) if auto_mode && key.is_some() => {
+                    tracing::debug!("Charm Hyper session request failed; trying API key");
+                }
+                Err(_) if auto_mode && key.is_some() => {
+                    // Upstream Auto retries with the API key after any
+                    // non-session response; an HTTP 429/5xx from the browser
+                    // lane must not hide a usable configured API credential.
+                    tracing::debug!("Charm Hyper browser response failed; trying API key");
+                }
+                Err(error) => return Err(error),
+            }
+        }
+
+        if auto_mode {
+            if let Some(key) = key {
+                return self.fetch_balance(Some(key), None, "api").await;
+            }
+            if cookie.is_some() {
+                return Err(ProviderError::AuthRequired);
+            }
+            return Err(missing_credential());
+        }
+
+        Err(if cookie.is_some() {
+            ProviderError::AuthRequired
+        } else {
+            missing_credential()
+        })
+    }
+}
+
+impl Default for HyperProvider {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait]
+impl Provider for HyperProvider {
+    fn id(&self) -> ProviderId {
+        ProviderId::Hyper
+    }
+
+    fn metadata(&self) -> &ProviderMetadata {
+        &self.metadata
+    }
+
+    async fn fetch_usage(&self, ctx: &FetchContext) -> Result<ProviderFetchResult, ProviderError> {
+        match ctx.source_mode {
+            // This repository's SourceMode::OAuth is the documented API-key
+            // lane for non-OAuth providers; upstream calls this source "api".
+            SourceMode::OAuth => {
+                let key = resolve_key(ctx)?;
+                self.fetch_balance(Some(&key), None, "api").await
+            }
+            SourceMode::Web => self.fetch_web(ctx, None, false).await,
+            SourceMode::Auto => {
+                let key = resolve_key(ctx).ok();
+                self.fetch_web(ctx, key.as_deref(), true).await
+            }
+            SourceMode::Cli => Err(ProviderError::UnsupportedSource(SourceMode::Cli)),
+        }
+    }
+
+    fn available_sources(&self) -> Vec<SourceMode> {
+        vec![SourceMode::Auto, SourceMode::Web, SourceMode::OAuth]
+    }
+
+    fn supports_web(&self) -> bool {
+        true
+    }
+}
+
+fn resolve_key(ctx: &FetchContext) -> Result<String, ProviderError> {
+    crate::providers::resolve_api_key(ctx.api_key.as_deref(), CREDENTIAL_TARGET, API_KEY_ENV)
+}
+
+fn is_rejected_session(status: StatusCode, headers: &reqwest::header::HeaderMap) -> bool {
+    status == StatusCode::UNAUTHORIZED
+        || status == StatusCode::FORBIDDEN
+        || status.is_redirection()
+        || (status == StatusCode::OK
+            && headers
+                .get(reqwest::header::CONTENT_TYPE)
+                .and_then(|value| value.to_str().ok())
+                .is_some_and(|value| value.to_ascii_lowercase().contains("text/html")))
+}
+
+fn status_error(status: StatusCode) -> ProviderError {
+    match status {
+        StatusCode::UNAUTHORIZED => ProviderError::AuthRequired,
+        StatusCode::FORBIDDEN => {
+            ProviderError::Other("Charm Hyper API key cannot access credits (HTTP 403).".into())
+        }
+        StatusCode::TOO_MANY_REQUESTS => {
+            ProviderError::Other("Charm Hyper credits requests are rate limited.".into())
+        }
+        status if status.is_server_error() => ProviderError::Other(format!(
+            "Charm Hyper credits service is unavailable (HTTP {status})."
+        )),
+        status => ProviderError::Other(format!("Charm Hyper API error: HTTP {status}.")),
+    }
+}
+
+#[derive(Debug, Deserialize)]
+struct CreditsResponse {
+    balance: f64,
+}
+
+fn parse_balance(body: &[u8]) -> Result<f64, ProviderError> {
+    let response: CreditsResponse = serde_json::from_slice(body).map_err(|_| {
+        ProviderError::Parse("Charm Hyper credits response is not valid JSON.".into())
+    })?;
+    if !response.balance.is_finite() || response.balance < 0.0 {
+        return Err(ProviderError::Parse(
+            "Charm Hyper balance must be a non-negative number.".into(),
+        ));
+    }
+    Ok(response.balance)
+}
+
+fn format_balance(balance: f64) -> String {
+    let rounded = if balance <= f64::MAX / 100.0 {
+        (balance * 100.0).round() / 100.0
+    } else {
+        balance
+    };
+    let formatted = format!("{rounded:.2}");
+    let (integer, fraction) = formatted
+        .split_once('.')
+        .unwrap_or((formatted.as_str(), ""));
+    let fraction = fraction.trim_end_matches('0');
+    let mut grouped = String::with_capacity(integer.len() + integer.len() / 3);
+    for (index, digit) in integer.chars().rev().enumerate() {
+        if index > 0 && index % 3 == 0 {
+            grouped.push(',');
+        }
+        grouped.push(digit);
+    }
+    let integer = grouped.chars().rev().collect::<String>();
+    if fraction.is_empty() {
+        integer
+    } else {
+        format!("{integer}.{fraction}")
+    }
+}
+
+fn missing_credential() -> ProviderError {
+    ProviderError::NotInstalled(
+        "Sign in to hyper.charm.land or configure a Charm Hyper API key.".into(),
+    )
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/rust/src/providers/hyper/tests.rs b/rust/src/providers/hyper/tests.rs
new file mode 100644
index 0000000000..94ba142c7c
--- /dev/null
+++ b/rust/src/providers/hyper/tests.rs
@@ -0,0 +1,203 @@
+use super::*;
+
+#[test]
+fn parses_exact_non_negative_hypercredit_balances() {
+    for (body, expected) in [
+        (br#"{"balance":0}"#.as_slice(), 0.0),
+        (br#"{"balance":12}"#.as_slice(), 12.0),
+        (br#"{"balance":18.5}"#.as_slice(), 18.5),
+    ] {
+        assert_eq!(parse_balance(body).unwrap(), expected);
+    }
+}
+
+#[test]
+fn rejects_missing_or_invalid_balance_values() {
+    for body in [
+        br#"{}"#.as_slice(),
+        br#"{"balance":"12"}"#.as_slice(),
+        br#"{"balance":-1}"#.as_slice(),
+        br#"{"balance":null}"#.as_slice(),
+        br#"{"balance":1e400}"#.as_slice(),
+        b"null".as_slice(),
+        b"[]".as_slice(),
+        b"not-json".as_slice(),
+    ] {
+        assert!(matches!(parse_balance(body), Err(ProviderError::Parse(_))));
+    }
+}
+
+#[test]
+fn formats_balance_to_two_fractional_digits_at_most() {
+    assert_eq!(format_balance(0.0), "0");
+    assert_eq!(format_balance(12.0), "12");
+    assert_eq!(format_balance(18.5), "18.5");
+    assert_eq!(format_balance(42.567), "42.57");
+    assert_eq!(format_balance(12_500.125), "12,500.13");
+}
+
+#[test]
+fn only_session_auth_redirect_and_html_responses_are_rejected_sessions() {
+    let mut html = reqwest::header::HeaderMap::new();
+    html.insert(
+        reqwest::header::CONTENT_TYPE,
+        "text/html; charset=utf-8".parse().unwrap(),
+    );
+    assert!(is_rejected_session(StatusCode::UNAUTHORIZED, &html));
+    assert!(is_rejected_session(StatusCode::FORBIDDEN, &html));
+    assert!(is_rejected_session(StatusCode::FOUND, &html));
+    assert!(is_rejected_session(StatusCode::OK, &html));
+    assert!(!is_rejected_session(
+        StatusCode::OK,
+        &reqwest::header::HeaderMap::new()
+    ));
+    assert!(!is_rejected_session(StatusCode::TOO_MANY_REQUESTS, &html));
+}
+
+#[test]
+fn classifies_api_statuses_without_echoing_response_bodies() {
+    assert!(matches!(
+        status_error(StatusCode::UNAUTHORIZED),
+        ProviderError::AuthRequired
+    ));
+    assert!(matches!(
+        status_error(StatusCode::FORBIDDEN),
+        ProviderError::Other(message) if message.contains("permissions") || message.contains("access")
+    ));
+    assert!(matches!(
+        status_error(StatusCode::TOO_MANY_REQUESTS),
+        ProviderError::Other(message) if message.contains("rate limited")
+    ));
+    assert!(matches!(
+        status_error(StatusCode::SERVICE_UNAVAILABLE),
+        ProviderError::Other(message) if message.contains("unavailable")
+    ));
+}
+
+#[tokio::test]
+async fn api_source_uses_bearer_key_and_displays_balance_without_quota_math() {
+    let mut server = mockito::Server::new_async().await;
+    let mock = server
+        .mock("GET", "/v1/credits")
+        .match_header("accept", "application/json")
+        .match_header("authorization", "Bearer fixture-api-key")
+        .with_status(200)
+        .with_header("content-type", "application/json")
+        .with_body(r#"{"balance":42.5}"#)
+        .create_async()
+        .await;
+    let provider = test_provider(&server.url());
+    let ctx = FetchContext {
+        source_mode: SourceMode::OAuth,
+        api_key: Some("fixture-api-key".into()),
+        ..FetchContext::default()
+    };
+
+    let result = provider.fetch_usage(&ctx).await.unwrap();
+    mock.assert_async().await;
+    assert_eq!(result.source_label, "api");
+    assert!(result.usage.primary.is_informational);
+    assert_eq!(result.display_details().len(), 1);
+    assert_eq!(result.display_details()[0].title(), "Hypercredits");
+    assert_eq!(result.display_details()[0].value(), "42.5 HC");
+    assert_eq!(result.usage.login_method.as_deref(), Some("API key"));
+}
+
+#[tokio::test]
+async fn auto_source_falls_back_from_rejected_session_to_api_key() {
+    let mut server = mockito::Server::new_async().await;
+    let session = server
+        .mock("GET", "/v1/credits")
+        .match_header("cookie", "session=fixture")
+        .with_status(401)
+        .create_async()
+        .await;
+    let api = server
+        .mock("GET", "/v1/credits")
+        .match_header("authorization", "Bearer fixture-api-key")
+        .with_status(200)
+        .with_header("content-type", "application/json")
+        .with_body(r#"{"balance":42.5}"#)
+        .create_async()
+        .await;
+    let provider = test_provider(&server.url());
+    let ctx = FetchContext {
+        source_mode: SourceMode::Auto,
+        manual_cookie_header: Some("session=fixture".into()),
+        api_key: Some("fixture-api-key".into()),
+        ..FetchContext::default()
+    };
+
+    let result = provider.fetch_usage(&ctx).await.unwrap();
+    session.assert_async().await;
+    api.assert_async().await;
+    assert_eq!(result.source_label, "api");
+    assert_eq!(result.usage.login_method.as_deref(), Some("API key"));
+}
+
+#[tokio::test]
+async fn auto_source_falls_back_after_session_rate_limit_or_server_error() {
+    for status in [429, 503] {
+        let mut server = mockito::Server::new_async().await;
+        let session = server
+            .mock("GET", "/v1/credits")
+            .match_header("cookie", "session=fixture")
+            .with_status(status)
+            .create_async()
+            .await;
+        let api = server
+            .mock("GET", "/v1/credits")
+            .match_header("authorization", "Bearer fixture-api-key")
+            .with_status(200)
+            .with_header("content-type", "application/json")
+            .with_body(r#"{"balance":42.5}"#)
+            .create_async()
+            .await;
+        let provider = test_provider(&server.url());
+        let ctx = FetchContext {
+            source_mode: SourceMode::Auto,
+            manual_cookie_header: Some("session=fixture".into()),
+            api_key: Some("fixture-api-key".into()),
+            ..FetchContext::default()
+        };
+
+        let result = provider.fetch_usage(&ctx).await.unwrap();
+        session.assert_async().await;
+        api.assert_async().await;
+        assert_eq!(result.source_label, "api");
+        assert_eq!(result.usage.login_method.as_deref(), Some("API key"));
+    }
+}
+
+#[tokio::test]
+async fn web_only_source_does_not_fall_back_to_configured_api_key() {
+    let mut server = mockito::Server::new_async().await;
+    let session = server
+        .mock("GET", "/v1/credits")
+        .match_header("cookie", "session=fixture")
+        .with_status(401)
+        .create_async()
+        .await;
+    let provider = test_provider(&server.url());
+    let ctx = FetchContext {
+        source_mode: SourceMode::Web,
+        manual_cookie_header: Some("session=fixture".into()),
+        api_key: Some("fixture-api-key".into()),
+        ..FetchContext::default()
+    };
+
+    assert!(matches!(
+        provider.fetch_usage(&ctx).await,
+        Err(ProviderError::AuthRequired)
+    ));
+    session.assert_async().await;
+}
+
+fn test_provider(base_url: &str) -> HyperProvider {
+    let client = Client::builder()
+        .redirect(Policy::none())
+        .timeout(API_TIMEOUT)
+        .build()
+        .unwrap();
+    HyperProvider::with_client(format!("{base_url}/v1/credits"), client)
+}
diff --git a/rust/src/providers/mod.rs b/rust/src/providers/mod.rs
index 0b4cdc2bff..d2f8ca4190 100755
--- a/rust/src/providers/mod.rs
+++ b/rust/src/providers/mod.rs
@@ -16,6 +16,7 @@ pub mod antigravity;
 pub mod augment;
 pub mod azureopenai;
 pub mod bedrock;
+pub mod bifrost;
 pub mod chart;
 pub mod chutes;
 pub mod claude;
@@ -37,10 +38,12 @@ pub mod elevenlabs;
 pub mod factory;
 pub mod fireworks;
 pub mod gemini;
+pub mod gitkraken;
 pub mod grok;
 pub mod groq;
 pub mod helmcode;
 pub mod huggingface;
+pub mod hyper;
 pub mod infini;
 pub mod jetbrains;
 pub mod kilo;
@@ -99,6 +102,7 @@ pub use antigravity::AntigravityProvider;
 pub use augment::AugmentProvider;
 pub use azureopenai::AzureOpenAIProvider;
 pub use bedrock::BedrockProvider;
+pub use bifrost::BifrostProvider;
 pub use chutes::ChutesProvider;
 pub use claude::ClaudeProvider;
 pub use clinepass::ClinePassProvider;
@@ -119,10 +123,12 @@ pub use elevenlabs::ElevenLabsProvider;
 pub use factory::FactoryProvider;
 pub use fireworks::FireworksProvider;
 pub use gemini::GeminiProvider;
+pub use gitkraken::GitKrakenProvider;
 pub use grok::GrokProvider;
 pub use groq::GroqProvider;
 pub use helmcode::HelmcodeProvider;
 pub use huggingface::HuggingFaceProvider;
+pub use hyper::HyperProvider;
 pub use infini::InfiniProvider;
 pub use jetbrains::JetBrainsProvider;
 pub use kilo::KiloProvider;
diff --git a/rust/src/settings/api_keys.rs b/rust/src/settings/api_keys.rs
index 9fa7544ee0..93ddb57226 100644
--- a/rust/src/settings/api_keys.rs
+++ b/rust/src/settings/api_keys.rs
@@ -619,6 +619,39 @@ pub fn get_api_key_providers() -> Vec<ProviderConfigInfo> {
             config_file_path: None,
             dashboard_url: Some("https://dev.meta.ai/docs"),
         },
+        ProviderConfigInfo {
+            id: ProviderId::Hyper,
+            name: "Charm Hyper",
+            requires_api_key: false,
+            api_key_env_var: Some("HYPER_API_KEY"),
+            api_key_help: Some(
+                "Optional. Sign in through hyper.charm.land browser cookies, or save an API key for API access.",
+            ),
+            config_file_path: None,
+            dashboard_url: Some("https://hyper.charm.land"),
+        },
+        ProviderConfigInfo {
+            id: ProviderId::GitKraken,
+            name: "GitKraken AI",
+            requires_api_key: true,
+            api_key_env_var: Some("GITKRAKEN_API_TOKEN"),
+            api_key_help: Some(
+                "Save a GitKraken access token. Optional organization ID: provider extras or GITKRAKEN_ORG_ID.",
+            ),
+            config_file_path: None,
+            dashboard_url: Some("https://gitkraken.dev/account#ai-usage"),
+        },
+        ProviderConfigInfo {
+            id: ProviderId::Bifrost,
+            name: "Bifrost",
+            requires_api_key: true,
+            api_key_env_var: Some("BIFROST_API_KEY"),
+            api_key_help: Some(
+                "Save a Bifrost virtual key and configure the gateway base URL in provider settings. Or set BIFROST_API_KEY and BIFROST_BASE_URL.",
+            ),
+            config_file_path: None,
+            dashboard_url: None,
+        },
     ]
 }
 
diff --git a/rust/src/settings/provider_workspace.rs b/rust/src/settings/provider_workspace.rs
index 338747c8ef..965a24cfb7 100644
--- a/rust/src/settings/provider_workspace.rs
+++ b/rust/src/settings/provider_workspace.rs
@@ -40,6 +40,14 @@ pub fn validate_provider_workspace_value(
             }
             Ok(trimmed.to_string())
         }
+        ProviderId::GitKraken => {
+            if trimmed.len() > 256 || !trimmed.bytes().all(|byte| (0x21..=0x7e).contains(&byte)) {
+                return Err(
+                    "GitKraken organization ID must be a single printable identifier".to_string(),
+                );
+            }
+            Ok(trimmed.to_string())
+        }
         ProviderId::V0 => validate_id(trimmed, "v0 scope", |value| {
             value.len() <= 128
                 && value
@@ -192,6 +200,12 @@ mod tests {
             validate_provider_workspace_value(ProviderId::Devin, "https://api.devin.ai").is_err()
         );
         assert!(validate_provider_workspace_value(ProviderId::OpenCodeGo, "wrk_abc/123").is_err());
+        assert_eq!(
+            validate_provider_workspace_value(ProviderId::GitKraken, " org-123 ").unwrap(),
+            "org-123"
+        );
+        assert!(validate_provider_workspace_value(ProviderId::GitKraken, "org id").is_err());
+        assert!(validate_provider_workspace_value(ProviderId::GitKraken, "org\n123").is_err());
     }
 
     #[test]